Durable execution for AI agents (2026)

Durable execution for an AI agent means the run survives a crash or a deploy and can wait for a person, a webhook, or a timer without holding a process open. In 2026 the options agents compare are Temporal, Restate, Inngest, DBOS, Vercel Workflow, and LangGraph’s checkpointing, and they differ most in what you run and how they treat code that changes while a run waits.

So pick Temporal for Signals, Updates, and Worker Versioning, Restate for one self-hosted binary, Inngest or Vercel Workflow for durable functions next to your TypeScript app, DBOS when Postgres is already your database, LangGraph when your agent is already a LangGraph graph, and Mastra workflows when it’s already a Mastra app. Every one of them runs your code, so you still write the agent. Cadenya is a hosted agent loop with approvals, resume, and conversation state built in, and nothing to host. What it offers is at the end.

Every price and limit below comes from each vendor’s own pages, checked on October 13, 2026.

Durable execution options side by side

	Temporal	Restate	Inngest	DBOS	Vercel Workflow	LangGraph
What you run yourself	Four services and a database (PostgreSQL, MySQL, or Cassandra)	One binary that stores its own state	One binary, SQLite by default, Postgres to scale	A library and a Postgres database	Nothing on Vercel. Elsewhere, a Postgres World	A library and a checkpointer database (Postgres, SQLite, MongoDB)
Managed option	Temporal Cloud, no base fee, $150 in credits	Restate Cloud, a Free plan with 100,000 durable actions a month	Inngest Cloud, free for 50,000 executions, Pro from $99 a month	DBOS Pro $99 a month, Teams $499 a month	Vercel, 50,000 events a month on Hobby	LangSmith Deployment, one free small serverless deployment on Plus
What you pay for	Actions, from $50 per million, plus storage and support	Durable actions, one per started 64 KiB	Executions: one per run plus one per step	Checkpoints, $50 per million past 1 million on Pro	Events ($0.02 per 1,000), data written and retained, function compute	Seats ($39 on Plus) and deployment compute and memory
The waiting primitive	Signals, Updates, durable timers	Awakeables (durable promises), durable sleep	step.waitForEvent, step.sleep	recv, events, durable sleep	Hooks, webhooks, sleep	interrupt() and Command(resume=...)
Code that changes while runs wait	Worker Versioning (pinned or auto-upgrade) and patching	Immutable deployments	Resumes on new code, reuses finished steps by ID	Version by code hash, or patching	Runs pinned to the deployment that started them	Graph migrations, with limits for interrupted threads
License	MIT	Business Source License 1.1	Server SSPL, SDKs Apache 2.0	MIT (Conductor is proprietary)	Apache 2.0	MIT
SDKs	Go, Java, Python, TypeScript, .NET, PHP, Ruby, Rust	TypeScript, Java and Kotlin, Python, Go, Rust	TypeScript, Python, Go	Python, TypeScript, Go, Java	JavaScript and TypeScript, Python	Python, JavaScript

Surviving crashes and deploys

All six record progress as the run goes, then replay it after a failure instead of starting over. What they record, and where, is the difference.

Temporal, Restate, Inngest, DBOS, and Vercel Workflow write every finished step to a log. After a crash, the run replays that log and skips the steps that already finished. DBOS says it plainly: an interrupted workflow “resumes the workflow from the last completed step.” Vercel says its runs “survive deployments and crashes with deterministic replays.”

LangGraph checkpoints the graph state instead, and you choose how often. In "sync" mode it “persists changes synchronously before the next step starts.” In "exit" mode it saves only when the graph stops, which means “you cannot recover from system failures (like process crashes) mid-execution.” Use a database checkpointer in production. The in-memory saver loses every checkpoint “when the process restarts.”

Replay has one rule in every engine: the code that runs again must make the same calls in the same order. So a model call, a tool call, or anything random goes inside a step or activity, where its result is saved the first time. LangGraph adds a twist of its own. On resume, “the node restarts from the beginning of the node where the interrupt was called,” so code above the interrupt() runs twice.

Human approval and other waits: wait for event, signals, and timers

Every option here can park a run, spend no compute while it waits, and resume it when something arrives. They name the parts differently.

Temporal waits on Signals and Updates, with durable timers for deadlines. Its AI cookbook says that while a workflow waits for approval, “the agent consumes no compute resources.” Restate creates an awakeable, hands its ID to the reviewer, and suspends: “If you wait for more than a minute, the invocation will get suspended.”

Inngest uses step.waitForEvent, which resolves with the matching event when it arrives, and step.sleep for timers.

DBOS uses recv and events to pass a message into a waiting workflow, and durable sleep for timers.

Vercel Workflow pauses on a hook. Here’s the hook from its docs:

import { createHook } from "workflow";

export async function approvalWorkflow() {
  "use workflow";

  using hook = createHook<{ approved: boolean; comment: string }>();

  console.log("Waiting for approval...");
  console.log("Send approval to token:", hook.token);

  // Workflow pauses here until data is sent
  const result = await hook;

  if (result.approved) {
    console.log("Approved with comment:", result.comment);
  } else {
    console.log("Rejected:", result.comment);
  }
}

Your API route calls resumeHook(token, { approved, comment }) when the reviewer clicks. Note the docs’ own warning: knowing the token “does not authorize the caller,” so check who’s calling first.

Temporal for durable AI agents

Temporal runs the agent loop as a Workflow and every model or tool call as an Activity. The Workflow holds the loop’s state, and each Activity’s result goes into the Event History, so a replay after a crash reuses it instead of calling the model again.

Temporal’s own description of the agent case: “Long-running, stateful agent loops that call LLMs and tools, wait on humans, and pick up exactly where they left off after a failure.”

You don’t have to write that split by hand. Temporal lists integrations for the OpenAI Agents SDK, the AI SDK by Vercel, Google ADK, LangGraph, Mastra, Pydantic AI, Strands Agents, Spring AI, and LangChain Deep Agents. In the OpenAI Agents SDK one, “the agent loop, tool selection, and handoffs” run inside the Workflow, while “model calls are executed as Activities, so they retry durably and are not repeated during Workflow replay.” The LangGraph plugin asks you to mark each node as an Activity or a Workflow node, and Workflow nodes “must be deterministic.”

For approvals, Temporal’s Approval pattern “uses Workflow Signals with custom input data to unblock Workflows.” Temporal’s AI Cookbook has a runnable human-in-the-loop recipe built on it.

LangGraph durable execution and checkpointers

LangGraph isn’t a workflow engine. It’s an agent framework with a persistence layer, and that layer is what makes it durable.

The checkpointer is the part to choose. Each one ships as its own package:

• InMemorySaver comes with langgraph-checkpoint, for experiments.
• langgraph-checkpoint-sqlite is “ideal for experimentation and local workflows.”
• langgraph-checkpoint-postgres is the one “used in LangSmith,” and LangChain calls it “ideal for using in production.”
• langgraph-checkpoint-mongodb and langchain-azure-cosmosdb cover MongoDB and Azure Cosmos DB.

Pick the durability mode next. "sync" writes every checkpoint before the next step starts, "async" writes it while the next step runs, and "exit" writes only when the graph stops.

You compile the graph with a checkpointer, pass a thread_id, and call interrupt() where a person needs to decide:

from langgraph.types import interrupt

def approval_node(state: State):
    # Pause and ask for approval
    approved = interrupt("Do you approve this action?")

    # When you resume, Command(resume=...) returns that value here
    return {"approved": approved}

The graph saves its state at the interrupt. You resume by invoking it again with Command(resume=True) on the same thread.

The wait is free, but the database is yours. The library is MIT and runs anywhere, with the checkpoint store you host. LangSmith Deployment runs it for you, and it bills on “uptime,” which LangChain defines as “the duration your deployment’s database is live and persisting state.”

Mastra durable workflows and suspend/resume

Mastra is a TypeScript agent framework, and its workflows are the durable part. A step calls suspend() to pause, and “suspension saves the current execution state as a snapshot.” Snapshots “persist across deployments and application restarts,” in libSQL by default, or in PostgreSQL, Upstash, or OracleDB.

You resume with the step and the data its resumeSchema expects:

const result = await run.resume({
  step: step1,
  resumeData: { approved: true },
})

To run the same workflows on Temporal, the @mastra/temporal package turns each createStep() handler into a Temporal Activity. TypeScript AI agent frameworks compared covers Mastra’s agents, tool approval, and memory in depth.

Durable execution in agent frameworks: OpenAI Agents SDK, Pydantic AI, and the AI SDK

Agent frameworks run the loop, and most of them get durability from one of the engines above. So the real question is which engine plugs in.

Pydantic AI documents it as a framework feature: durable agents “preserve their progress across transient API failures and application errors or restarts.” It “supports eight durable execution solutions,” and five are co-maintained with the vendor: Temporal, DBOS, Prefect, Restate, and AWS Lambda. Each engine “wraps every model request and tool call as its own durable unit,” and durable agents keep “full support for streaming and MCP.”

The OpenAI Agents SDK lists its durable integrations on the running agents page. The Temporal one runs agents as durable workflows, “including human-in-the-loop tasks.” Restate, DBOS, and Dapr have integrations there too, and the DBOS one “requires only a SQLite or Postgres database.”

The AI SDK gets durability from WorkflowAgent in @ai-sdk/workflow. It runs the same loop as ToolLoopAgent inside a workflow, “where each tool execution is a durable step with automatic retries.” Streaming goes through the workflow’s writable stream, and WorkflowChatTransport reconnects a stream that drops and resumes it “from where it left off.” Durable agents with the Vercel AI SDK covers the setup.

Pick the framework for the agent, then the engine that keeps it running.

Self-hosted or managed, and what durable workflows cost

The self-hosted footprint ranges from a library to a cluster. DBOS and LangGraph are libraries plus a database. Restate and Inngest are one binary each. Temporal is “four independently scalable services” and a database.

The managed bills count different things:

• Temporal Cloud charges per Action. Timers, Signals, and each activity start are all Actions, at $50 per million to start, dropping to $25 at volume.
• Restate Cloud charges per durable action, and awakeables and sleeps count.
• Inngest charges per execution, one per run plus one per step. Its pricing FAQ says an agent with tool calls, retries, or sub-agent handoffs uses “often 10+ executions per run.”
• DBOS charges for Conductor, its management console, by checkpoint. The Transact library itself is “free forever.”
• Vercel Workflow charges per event, and “a normal step function execution produces three events.” Function compute is billed on top.

For an agent that runs a few thousand times a month, the engine bill is small on all of them. The big number is the code you write and run around it. The Temporal cost breakdown walks through a worked example, and the hosted runtimes guide compares the options that run the loop for you.

Worker versioning: code that changes while runs wait

A run that waits for a person often sees a deploy or two. Each engine answers that differently.

Temporal lets you pick per workflow. A Pinned workflow “is guaranteed to complete on a single Worker Deployment Version,” so the old workers keep running until the last pinned run closes. An Auto-Upgrade workflow moves to new code and needs patching to stay replay-safe.

Restate makes every deployment immutable, so “you need to keep old deployments around until all invocations complete.” Vercel Workflow does the same by default: a waiting run “still resumes on the original deployment,” and you opt into new code with deploymentId: 'latest'.

Inngest goes the other way. “When a run resumes, Inngest uses the current code and reuses results from completed steps whose IDs still match.” A rewrite gets a new function ID while the old one stays deployed.

DBOS offers both models. With versioning, it “only continues workflow execution with the same application version that started the workflow,” and the version is a hash of your code by default. With patching, a DBOS.patch() check picks the old or new path.

LangGraph handles graph migrations, with one gap: for a thread that’s waiting on an interrupt, it supports “all topology changes other than renaming / removing nodes.”

For deeper head-to-heads, see Restate vs Temporal, Inngest vs Temporal, and DBOS vs Temporal.

What does Cadenya offer that durable execution engines don’t?

Temporal, Restate, Inngest, DBOS, Vercel Workflow, LangGraph, and Mastra make your code durable, and your code still has to be the agent. Cadenya is the agent loop itself, with durable state, human-in-the-loop approvals, and resume built in, and nothing to host. Here’s what that covers:

1. Nothing else to run. No cluster, no binary, no workers, no checkpoint database, and no deployment to keep warm. The loop runs on Cadenya, so your deploys and restarts never touch a running objective.
2. A durable record of every run, with no replay rules. “Every Objective carries a durable event log of its agent loop,” and you can list it after a run or stream it live. You don’t wrap model calls in steps or keep your code deterministic, because Cadenya runs the loop.
3. Approvals that park the loop. Mark a tool as needing approval and Cadenya “parks the Agent loop until it receives approval or a denial with optional steering.” Several tool calls can wait at once, and a denial can carry a memo like “Use the read-only lookup tool instead.”
4. Wait for an answer from anywhere. A Bare tool set sends your app a tool_called webhook, and your app sets the result through the API once a person answers in Slack, by email, or in another channel. That’s the wait-for-event pattern with no hook tokens or awakeable IDs to route.
5. Conversations that resume. When an objective reaches STATE_WAITING, a Continue message from your user picks the loop back up with its chat history. Cadenya compacts the context window when a conversation gets long.
6. No old code to keep alive. “The Objective keeps that variation’s configuration snapshot even if you edit the variation later.” So there’s no worker version to pin, no deployment to drain, and no patch branch to remove later.
7. Model swaps without a deploy. The model is a setting on a variation, not a line of code. Switch providers, or let weighted variations favor the one users rate higher.
8. No duplicate runs. Pass an External ID from your own record, and Cadenya uses it “to prevent duplicate Objectives for a workflow or record in your application.”
9. SDKs for the versions you run today. TypeScript on Node 18, Python 3.9, Ruby 3.1, and Go 1.22, all at 1.9.0 and Apache-2.0, plus a CLI and a plain HTTP API. Webhooks follow Standard Webhooks with an HMAC signature.
10. A price in one line. Free for 1,000 loops a month, $49 a month for 50,000, then $0.0015 a loop. A loop is one LLM request.

How objectives work covers events, approvals, and Continue, and the free plan needs no card.

Create an account at app.cadenya.com/signup, then copy your API key from the API keys page.