An agent run with 30 model calls and 20 tool calls bills about 51 units on Restate Cloud, Inngest, Temporal Cloud or DBOS, and 100,000 runs a month costs roughly $80 to $310. Your model tokens for the same runs cost over 200 times more. So the meter is the wrong place to decide. Pick DBOS if your agents are Python or TypeScript and you already run Postgres. Pick Temporal if several teams, several languages, or runs that wait for days are involved. Restate is the cheapest managed meter at this workload but the youngest and BSL-licensed. Inngest is the one to avoid for long agent loops: a hard 1,000-step cap per run, an SSPL server, and concurrency limits that sit exactly where agents push.
The trap the buyer falls into is pricing on a demo. A three-step demo workflow is 4 executions on Inngest; your real agent is 51. A free tier that looks like 12,500 runs a month is closer to 980.
All prices below were checked on October 16, 2026.
| Temporal Cloud | Inngest | Restate Cloud | DBOS | |
|---|---|---|---|---|
| Billing unit | Action | Execution (run + each step) | Durable action | Checkpoint |
| Units per agent run (30 model + 20 tool calls) | 51 | 51 | 52 | 51 |
| Entry paid plan | Developer: no base fee, $50/M actions + 10% support | Pro: $99/mo, 1M executions | Starter: $75/mo, 5M actions | Pro: $99/mo, 1M checkpoints |
| Cost at 100K runs/month (engine only) | ~$280 + storage | $160 to $304 | ~$80 | ~$304, or $0 without Conductor |
| Self-host licence | MIT | SSPL (Apache 2.0 after 3 years) | BSL 1.1 (Apache 2.0 after 4 years) | MIT |
| Self-host footprint | Server cluster + Postgres/MySQL or Cassandra | Single binary; Postgres + Redis to scale out | Restate server under BSL terms | A library on your Postgres |
| Hard per-run ceiling | 51,200 events / 50 MB history | 1,000 steps, 32 MiB state | Not published on the pages checked | Your Postgres |
| Who should not pick it | Small teams planning to self-host | Long or open-ended agent loops | Procurement that needs first-party price proof | Polyglot fleets, teams without Postgres |
| Verdict | Best for multi-team scale | Loser for agents | Cheapest managed meter | Default pick |
What Durable Execution Gives an Agent
Durable execution is a runtime guarantee that a function's progress is journaled step by step, so after a crash it resumes from the last completed step instead of starting over. For an agent, that buys four specific things.
First, a crashed run does not re-pay for model calls it already made. Temporal's OpenAI Agents SDK integration runs each model call as an Activity, and the docs say model calls "retry durably and are not repeated during Workflow replay." Second, a run can wait for a human approval for days without a process held open: a timer or signal sits in the journal, and the worker can be redeployed underneath it. Third, the journal is the audit trail of what the agent did and in what order. Fourth, tool calls with side effects run once per completed step.
That last one needs care. Every engine here retries a step that crashed mid-flight, because it cannot know whether the call landed before the crash. So the guarantee is "a completed step is never re-run," which is weaker than exactly-once delivery to the outside world. LangGraph's durable execution docs give the right advice for every engine: use idempotency keys or check for an existing result before a tool call that charges a card, sends an email or files a ticket.
How Each Meter Counts One Agent Run
Each vendor counts the same run almost identically, which is why the totals cluster. The workload for every number below: one agent run makes 30 model calls and 20 tool calls, each wrapped as its own step, with no retries, at 100,000 runs a month.
Temporal Cloud bills Actions. Per the Actions reference, a Workflow start is one Action and every Activity start or retry is one, as are Timers (including implicit timeout timers), Signals, Queries and Updates. Actions during replay are free. One run is 1 start plus 50 Activities, or 51 Actions, so 100K runs is 5.1M Actions. The pricing docs put the Developer plan at a flat $50 per million Actions at every volume, plus 10% of usage as a support fee. That is $255 of usage plus $25.50, about $280. The Business plan starts at the greater of $500 a month or 10% of usage and includes 2.5M Actions.
Temporal also bills storage, which matters for agents that wait. Active storage on pay-as-you-go is $0.042 per GB-hour per the pricing page. Assume each run's history is 200 KB (an assumption: it depends on how much prompt and output you pass through Activity payloads) and 10% of runs wait three days for an approval. About 1,000 runs are then open at any moment, roughly 0.2 GB, which is around $6 a month. Pass the full transcript into every model call instead of a reference, and a run's history grows toward several megabytes; that bill grows tenfold or more and you start hitting history limits (below).
Inngest bills executions: each function run counts once, and each step inside it counts once. The pricing page gives the formula as runs × (steps + 1), so one agent run is 51 executions and 100K runs is 5.1M. Pro is $99 a month with 1M included. The remaining 4.1M are billed "at tiered rates that decrease as volume grows," from $0.000050 to $0.000015 per execution, but the page does not publish the band boundaries. The honest range is $61.50 to $205 of overage, or $160 to $304 total. Ask sales for the bands in writing.
Restate Cloud bills durable actions: an invocation, each intermediate step, durable sleeps, RPC calls and the completion, with state reads and writes unmetered. One run is about 52 actions, 5.2M a month. Starter is $75 a month with 5M included, and extra actions are $25 per million, so about $80. Business is $300 with 20M. One caution on sourcing: Restate's pricing page renders in the browser and would not load in our fetcher on October 16, so these plan figures come from DevTune's mirror of it, updated October 15, 2026. Confirm on the live page before you put it in a budget.
DBOS bills checkpoints (workflows, steps and transactions) only if you buy Conductor, its management plane. Per the pricing page, Pro is $99 a month with 1M checkpoints and $50 per extra million; Teams is $499 with 10M included and $40 per extra million. One run is 51 checkpoints, so Pro comes to $99 + 4.1M × $50/M = $304, and Teams covers it at a flat $499. The detail that changes the math: the DBOS Transact library is MIT-licensed and writes checkpoints to your own Postgres. Conductor adds the console, distributed recovery and versioning tools; the durability itself works without it, for $0 plus the Postgres you already pay for.
Now the denominator. At Claude Sonnet 5.5's list price of $2 per million input tokens and $10 per million output, a model call with 8,000 input tokens and 500 output tokens costs about $0.021. Thirty of them is $0.63 a run, or $63,000 a month at 100K runs before caching. The most expensive engine bill above is under 0.5% of that.
Where Each Engine Breaks on an Agent Loop
The differences that predict regret are the limits, and agents find them faster than ordinary workflows do because the loop length is decided by a model.
Temporal caps a single workflow's history at 51,200 events or 50 MB, warns at 10,240 events or 10 MB, and caps any single payload at 2 MB. A 50-step run uses a few hundred events, which is fine. A chat-style agent session that runs for weeks is not, and needs Continue-As-New to start a fresh history. Payload size bites earlier. Pydantic AI's Temporal guide warns that every recorded payload sits in the event history under that 2 MB limit and points to external storage for large content. Store transcripts and documents outside the journal and pass references.
Inngest stops a function at 1,000 steps, with 4 MiB per step output and 32 MiB of total run state. Max run length is plan-bound: 30 days on Free, 90 on Pro, 366 on Business. An agent that loops 500 times with a model step and a tool step hits the step cap and fails. You can bound the loop, but that is a product decision forced by a vendor limit. Pro also includes only 100 concurrent steps, then $25 per 25 more. In Inngest's favour, step.ai.infer() hands the model request to Inngest's infrastructure and pauses the function while it waits, so a serverless deployment does not pay for compute while the model thinks. If you deploy on Vercel or Lambda, that is a real saving the other three do not offer in the same form.
Restate documents agent integrations for the Vercel AI SDK, OpenAI Agents SDK, Google ADK, Pydantic AI and LangChain, and its AI docs say to wrap LLM calls in ctx.run() so "every LLM call and tool execution is durably persisted." The plan tiers on the mirror also set history retention short on the cheap plans (1 day on Free, 3 on Starter, 7 on Business). If your audit story depends on reading the journal a month later, export it or move up a tier.
DBOS has no engine-side ceiling because the journal is rows in your Postgres. The ceiling is your database: every step is a write to the same Postgres your application may already depend on. Its OpenAI Agents integration swaps Runner.run for DBOSRunner.run and has you mark tools and guardrails with @DBOS.step. The page does not state whether model calls themselves are checkpointed as steps, so test a kill-and-restart before you trust that a crashed run will not re-call the model.
What Replay Demands of Code That Calls a Model
Replay engines re-run your orchestration code from the top after a crash and feed it the recorded results of completed steps, so that code must make the same decisions on the second pass. A model is the least deterministic thing in your stack, so the rule is absolute: the model call goes inside a step, and nothing outside a step may read the clock, a random number, the network or a file.
The integrations handle the model call for you. The failure mode is everything around it. Temporal's docs note that a plain @function_tool runs inside the Workflow unless you back it with an Activity, so a tool that calls an API from workflow context will run again on every replay. Approval callbacks and MCP tool filters also run in Workflow context and must be deterministic. Pydantic AI adds that event-stream handlers re-run on every replay. Code changes are the second failure mode: change the order of steps while runs are in flight, and replay of an old run no longer lines up with the new code. Each engine has a versioning mechanism for that, and each needs discipline.
Trigger.dev co-founder Eric Allam made the strongest case against replay for agents in a 2025 AI Engineer talk: "An agent is a session, and that session may continue for as long as its user wants to keep working." The journal grows without bound, and replay does not restore the cloned repo or running process a coding agent works in. He argues for an append-only context log plus machine snapshots. It is a vendor's argument for its own design, but the diagnosis is right for coding agents with a working directory. For agents that call APIs and reason over text, replay is fine.
What Self-Hosting Really Costs
Self-hosting swaps a few hundred dollars of meter for infrastructure and engineering time. At 100K runs a month that trade loses badly on Temporal, and DBOS has no server to self-host in the first place.
The Temporal server is MIT-licensed, about 23,800 GitHub stars, and runs as a multi-service cluster on Postgres, MySQL or Cassandra. Quo (formerly OpenPhone) wrote up moving its self-hosted Temporal from Aurora Postgres to Cassandra after it "hit the single-writer wall," and describes the trade plainly: per-action pricing replaced by running clusters and paging engineers when something breaks. Quo already had a large EKS footprint and SRE staff. Automation Atlas's self-host estimate, a third-party guide, puts a small production cluster at about $2,500 to $4,500 a month in infrastructure plus 0.25 to 1.0 FTE of operations labour. Set that against a Cloud bill of about $280.
Inngest self-hosts as a single binary that defaults to SQLite and in-memory Redis, but SQLite "does not support scaling beyond a single node," so scaling out needs external Postgres (the docs also recommend your own Redis), and old runs are not cleaned up automatically. Inngest's licence is SSPL, which converts to Apache 2.0 three years after each release. Fine for internal use; a problem if you build a product that exposes it to customers.
Restate's licence is BSL 1.1 with an additional use grant that allows production use, including internal platforms, but forbids a public Restate platform service where outside parties call Restate's APIs directly. Each version converts to Apache 2.0 after four years.
DBOS is the outlier: there is no server to host. The library runs inside your application processes and uses Postgres tables for state. Self-hosting costs the Postgres capacity the checkpoints consume, and nothing else unless you want Conductor.
When Your Framework's Checkpointing Is Enough
A separate engine is often unnecessary. LangGraph checkpoints graph state with three durability modes: exit persists only when a run finishes or pauses at an interrupt, async writes checkpoints while the next step runs, and sync writes before the next step starts. With sync and a Postgres checkpointer, a crashed LangGraph agent resumes from its last node and does not re-pay for completed model calls. Human-in-the-loop interrupts survive a restart too.
The token math gives you the break-even. With no durability at all, a run that crashes at a random point wastes on average half its model spend, here about $0.32. At a 1% crash rate that is 1,000 runs and roughly $315 a month in re-spent tokens, about the most expensive engine bill in the table. But framework checkpointing saves those tokens too, so tokens are not why you add an engine.
You need the separate engine when one of these is true. Your tool calls have side effects you cannot make idempotent, and you need the per-step retry, timeout and history machinery to reason about them. Runs wait longer than a deploy cycle, so you need timers and signals that survive your process being replaced, plus versioning for code that changed while runs were parked. Or several services in different languages take part in one agent run. If your runs finish in under about 10 minutes, fail less than 1% of the time, and call read-only tools, sync checkpointing in your framework is enough, and adding an engine buys you a second system to operate. Those thresholds are judgment, derived from the math above; move them if your model calls are larger.
Who Should Not Pick Each One
Skip Temporal if you are a team of fewer than about five engineers planning to self-host, or if your agents are single-process scripts that finish in minutes. You would pay for the determinism discipline and the cluster and use neither.
Skip Inngest if your agent's loop length is open-ended, because the 1,000-step cap turns into a production failure, or if you would self-host it inside a product sold to customers, given SSPL. It loses this comparison because its limits land on the exact things that make agents different from ordinary workflows: step count, run state and concurrency.
Skip Restate if your procurement needs a vendor-hosted price sheet it can verify today, or if you want to resell a platform where customers call Restate's APIs. Retention on the low tiers is also short for audit use.
Skip DBOS if your fleet runs languages beyond its Python, TypeScript, Go and Java SDKs, or if your Postgres is already the bottleneck. Every step is a write on that database.
How to Decide
This Week: Count your real units. Take one production agent trace, count model calls, tool calls, sleeps and signals, and multiply by monthly runs. Price that number, not the demo.
This Month: Run the kill test on your top two candidates. Start a 50-step run, kill the worker mid-model-call, restart it, and check two things in your model provider's logs: that completed calls were not repeated, and that the interrupted call was retried exactly once. Then change a step's position in the code with a run parked on an approval and see whether the engine's versioning saves you.
Before You Sign: Get Inngest's overage bands and Restate's rates in writing, and ask each vendor how retries, sleeps and signals are counted, because those are where an agent's real unit count drifts above 51.
Continue Reading
- LangChain Alternatives: Fix Durability Before You Rewrite
- OpenAI Agents SDK Alternatives: Leave Three Features, Not the SDK
- Zapier and n8n Alternatives Once Workflows Become Agents
- Human-in-the-Loop for AI Agents: Most Approval Gates Rubber-Stamp
- LangGraph vs CrewAI vs AutoGen: One of Them Is Retired
- Why Temporal Lost to Mistral in the $2B AI Orchestration War