Durable Agent Execution & Long-Running Agent Runtimes
Parent: AI Agent Ecosystems · Published reference · snapshot 2026-09-08
↓ Facts as markdownall context files
The infrastructure/platform layer that lets AI agents run for minutes, hours,
These notes link each claim to its source. Some citations identify archived research reports that are no longer hosted on this site. A published reference means the content is available; it does not certify independent review or accuracy.Read the editorial policy and follow the sources before relying on a claim.
Durable Agent Execution & Long-Running Agent Runtimes
- The infrastructure/platform layer that lets AI agents run for minutes, hours, or days and survive process crashes, deploys, and long waits. It checkpoints agent progress, replays or restores state on recovery, pauses indefinitely for human approval, and makes tool side effects exactly-once. This skill covers the PLATFORMS that make agent loops durable - not how to design the loop logic itself. [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#durable-agent-execution-long-running-agent-runtimes]
When to use / Skip
- Use when you are choosing, integrating, or debugging the runtime beneath a long-running agent: [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#when-to-use-skip]
- An agent must survive a pod restart / deploy mid-run without losing state. [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#when-to-use-skip]
- A run must pause for human approval (HITL) and resume later - without holding a worker, socket, or compute. [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#when-to-use-skip]
- A failed run must resume from step N, not re-run completed (paid) LLM/tool work. [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#when-to-use-skip]
- Tool calls that write to a DB, send email, or charge a card must not double-fire. [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#when-to-use-skip]
- You are picking among Temporal / LangGraph / DBOS / Restate / Inngest / Cloudflare / Trigger.dev / Vercel Workflow / Hatchet / Resonate. [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#when-to-use-skip]
- You hit a NondeterminismError or ask "where do my LLM calls go?" [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#when-to-use-skip]
- Skip - defer to the right neighbor: [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#when-to-use-skip]
- Designing the agent loop (sequential pipeline, infinite loop, RFC-driven DAG, REPL loop) -> autonomous-loops. We make loops durable; that skill designs them. [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#when-to-use-skip]
- Multi-agent topologies / councils / handoff routing -> ai-agents-orchestration (this skill is the deep durable-execution spoke that hub routes to). [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#when-to-use-skip]
- Agent memory architecture / context engineering -> ai-mcp-sdk-prompting. [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#when-to-use-skip]
- Generic (non-agent) job scheduling, MV3 alarms, SSE streaming -> software-engineering-patterns. [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#when-to-use-skip]
- Eval/observability of agent quality -> ai-agents-orchestration (references/eval-driven-development.md) / ai-llm-model-layer (references/llm-observability.md). [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#when-to-use-skip]
The durable-execution model
- Workflow-as-code + a journal. You write ordinary-looking async code; the runtime records every step's input/output into an append-only event log (a "journal" or "checkpoint"), keyed per execution/thread. On crash, the runtime restores the pre-failure state so the function continues "effectively once and to completion - whether it runs for seconds or years." [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#the-durable-execution-model]
- Three architectural camps solve this. This axis drives every selection decision below: [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#the-durable-execution-model]
Camp 1 — Deterministic replay / event sourcing
- On recovery the workflow function is re-executed from the start, but completed steps return their recorded results instead of re-running. This demands the workflow body be deterministic: same inputs -> same command sequence. Hence all non-determinism - LLM calls, tool I/O, time, randomness, UUIDs - must live in journaled steps/activities, outside the replay path. This is THE friction when applying classic durable execution to agents. [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#camp-1-deterministic-replay-event-sourcing]
- Temporal: NondeterminismError if re-generated commands don't match the Event History. Use SDK-provided replay-safe time/random; move all I/O to Activities; write replay tests before changing workflow code. [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#camp-1-deterministic-replay-event-sourcing]
- The "function looks normal but is secretly re-run many times" mental model is shared by Restate, DBOS, Resonate, and Vercel WDK ("must be deterministic to allow resuming after failures"). [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#camp-1-deterministic-replay-event-sourcing]
Camp 2 — State-checkpoint snapshots
- Instead of replay-from-start, the runtime saves a snapshot of graph state at every super-step - a checkpoint - keyed by thread. Resume = load the latest checkpoint and continue. No determinism constraint on node bodies. Caveat: replay/time-travel re-executes nodes after the chosen checkpoint, so LLM/API/interrupt calls there fire again and may differ. [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#camp-2-state-checkpoint-snapshots]
Camp 3 — Durable actor
- Each agent is an addressable stateful micro-server with an embedded SQLite DB. It consumes zero compute when hibernated, wakes on an event (HTTP / WebSocket / alarm / email), reads its state, works, then sleeps. State lives with the actor, not in a central journal. [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#camp-3-durable-actor]
Temporal — the category-definer (deterministic replay)
- Model: Workflow (deterministic orchestrator) + Activity (non-determinism sink, auto-retried, result recorded in Event History). On replay, Activities are NOT re-run - recorded results are reused. [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#temporal-the-category-definer-deterministic-replay]
- Agent fit: put every LLM call + tool call in an Activity. Official OpenAI Agents SDK integration (late 2025). Signals deliver external/human input to a running workflow (HITL); Queries read state; durable Timers for delays; ContinueAsNew to trim unbounded history. [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#temporal-the-category-definer-deterministic-replay]
- Ops: heavyweight - server cluster (History/Matching/Frontend) + Cassandra/ Postgres + Elasticsearch + a separately deployed worker fleet. MIT; self-host or Temporal Cloud. SDKs: Go/Java/Py/TS/.NET/PHP/Ruby. [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#temporal-the-category-definer-deterministic-replay]
- Best for: multi-tenant, multi-region, very-high fan-out, mission-critical, >4h tasks where full restart cost exceeds the Cloud bill. [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#temporal-the-category-definer-deterministic-replay]
LangGraph / LangSmith Deployment — state-checkpoint, agent-native
- Renamed: "LangGraph Platform" (GA May 2025) -> "LangSmith Deployment" (Oct 2025). Same product; both names appear in the wild. [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#langgraph-langsmith-deployment-state-checkpoint-agent-native]
- Persistence: compile the graph with a checkpointer (Postgres/SQLite/ memory) -> a state snapshot is saved every step, organized into threads (thread_id is the resume pointer). [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#langgraph-langsmith-deployment-state-checkpoint-agent-native]
- HITL: interrupt(payload) pauses at an exact point, persists state, and waits indefinitely; resume with Command(resume=value). Payload must be JSON-serializable. Use a durable checkpointer in production. [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#langgraph-langsmith-deployment-state-checkpoint-agent-native]
- Time-travel: Replay (re-run from a prior checkpoint_id) and Fork (update_state at a past checkpoint -> branch an alternative trajectory). Nodes after the checkpoint re-execute; interrupts always re-trigger. [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#langgraph-langsmith-deployment-state-checkpoint-agent-native]
- Assistants API: one deployed graph -> many assistants (versioned configs: prompts/models/tools), promote/rollback versions. ~30 server endpoints; Remote Graphs for distributed multi-agent; LangGraph Studio for debugging. [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#langgraph-langsmith-deployment-state-checkpoint-agent-native]
Cloudflare Agents SDK — durable actor on Durable Objects
- Model: class X extends Agent; each instance = one Durable Object with its own SQLite DB + WebSocket connections + scheduling. Wakes on event, hibernates when idle (zero compute). [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#cloudflare-agents-sdk-durable-actor-on-durable-objects]
- State: this.setState() serializes + persists to SQLite and broadcasts to connected clients; this.state lazily loads; this.sql for tables. Survives evictions/deploys/hibernation. [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#cloudflare-agents-sdk-durable-actor-on-durable-objects]
- Hibernation: WebSocket clients stay connected to Cloudflare's edge while the DO sleeps; on next event the constructor re-runs (keep it light). Use serializeAttachment/deserializeAttachment to restore per-connection state. [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#cloudflare-agents-sdk-durable-actor-on-durable-objects]
- Scheduling: this.schedule(60|Date|"cron", "method") and scheduleEvery(s) wrap DO alarms; stored in cf_agents_schedules; cron self-reschedules. Survives restarts. [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#cloudflare-agents-sdk-durable-actor-on-durable-objects]
- Long work: keepAlive() holds an alarm-backed heartbeat so the DO isn't evicted mid-stream; runFiber()/stash() checkpoint & recover long tasks; waitForApproval() for HITL; runWorkflow() delegates heavyweight multi-step work to Cloudflare Workflows; subAgent() for children. [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#cloudflare-agents-sdk-durable-actor-on-durable-objects]
Inngest (+ AgentKit) — serverless-first memoized steps
- Core: step.run("name", fn) is a durable, auto-retried, memoized unit - on resume, completed steps return cached results instantly. step.waitForEvent() pauses for HITL/coordination; step.sleep for durable sleep (hours->weeks); step.sendEvent() fire-and-forget. Declarative cancellation by event. Priced per step. [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#inngest-agentkit-serverless-first-memoized-steps]
- AgentKit (separate TS framework): builds multi-agent Networks with a Router + shared State - "a while loop with memory." The Network/Router loop is orchestration (-> autonomous-loops / orchestration); durability comes from wrapping network.run() inside an inngest.createFunction to inherit retries, concurrency, and throttling. This is the cleanest illustration of the loop-vs-runtime boundary. [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#inngest-agentkit-serverless-first-memoized-steps]
DBOS — durable execution *inside Postgres* (no orchestrator)
- Model: install the OSS library, annotate @DBOS.workflow / @DBOS.step. Step outputs + workflow state are checkpointed to a Postgres "system database." No separate orchestrator - app servers cooperatively dequeue workflows from a Postgres table and checkpoint steps themselves. [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#dbos-durable-execution-inside-postgres-no-orchestrator]
- Recovery: detect interrupted workflows -> re-call with checkpointed inputs -> each step checks Postgres for a saved output and skips if present -> first un-checkpointed step runs normally. = resume from last completed step. [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#dbos-durable-execution-inside-postgres-no-orchestrator]
- Agent extras: fork a workflow (copy checkpoints up to step N, restart from there - "git branch for an agent run"). Durable queues with global/per-worker/ per-tenant flow control. Native OpenAI Agents SDK integration; Databricks partnership (Apr 2026, runs on Lakebase Postgres). Go SDK (2026). Py/TS/Go/Java. Lowest barrier if you already run Postgres; throughput ceiling + PG lock-in are the trade-offs. [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#dbos-durable-execution-inside-postgres-no-orchestrator]
Restate — lightweight journal/replay, Rust single binary
- Core abstractions: Virtual Objects (stateful keyed entities with serialized per-key concurrency), Workflows, Services. Journals completed steps; replay returns cached results. Embedded RocksDB + arbitrary external storage; HTTP/2 + Connect/gRPC; per-handler idempotency. Single binary or Restate Cloud. BSL. Go/Java/TS/Py/Rust/Kotlin. Best when you want durable execution + stateful entities without operating a cluster; strong for serverless/edge. [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#restate-lightweight-journalreplay-rust-single-binary]
Hatchet — durable task queue on Postgres
- Durable tasks checkpoint to a durable event log every time they wait (sleep/event) or spawn children; replay resumes from the last checkpoint with exactly-once semantics. While waiting, Hatchet evicts the task off the worker slot and re-queues it later - ideal for agentic loops with long HITL waits. Offers both DAGs (static) and durable tasks (runtime-dynamic). Postgres for both runtime + observability (easy self-host). MIT. Py/TS/Go/Ruby. [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#hatchet-durable-task-queue-on-postgres]
Trigger.dev (v3) — no-timeout durable serverless via CRIU
- Write linear async code; wait.for({hours:1}) / wait.until(date) / wait.forToken() (HITL: token has a callback URL, complete via HTTP POST, resume with wait.forToken()); triggerAndWait() / batchTriggerAndWait(). No timeouts - code runs in a container paused/resumed via CRIU (Checkpoint/Restore In Userspace); checkpointed waits don't bill compute. OSS with the most mature self-host path (Postgres + Redis + S3-compatible store) or Cloud. [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#triggerdev-v3-no-timeout-durable-serverless-via-criu]
Resonate — distributed async/await (emerging)
- "Durable Executions, Dead Simple." ctx.run() (durable step), ctx.sleep(), ctx.rpc(), and Durable Promises (await human/external input for days). Deterministic replay; single-binary Resonate Server. Maturity caveat: early - v0.9.1, repo created Apr 2026, single-digit GitHub stars. Track for the model; do not treat as a Temporal peer yet. [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#resonate-distributed-asyncawait-emerging]
Vercel Workflow — durability as a language directive
- OSS Workflow Development Kit (WDK) + managed Vercel Workflows (beta Oct 2025 -> GA; 100M+ runs, 500M+ steps). Two directives: "use workflow" (durable fn) and "use step" (isolated, persisted, retried unit; default 3 retries). sleep("1 month") suspends with zero resources; createWebhook() returns a URL to resume on external/human input. Durable streams: getWritable() survives client disconnect/reconnect. Deep AI SDK integration. TS + Python. [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#vercel-workflow-durability-as-a-language-directive]
Core capabilities (cross-cutting)
- Checkpointing / state persistence: journal of step outputs (Temporal, Restate, DBOS, Inngest, Hatchet, Resonate, Vercel) vs state snapshot per node (LangGraph) vs actor-embedded SQLite (Cloudflare). Always use a durable backend in prod, never in-memory. [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#core-capabilities-cross-cutting]
- HITL interrupt & resume: the unifying requirement is pause without holding compute/worker/socket, resume on an external event. LangGraph interrupt() + Command(resume=); Temporal Signals; Inngest waitForEvent; Trigger.dev/Vercel webhook-or-token; Resonate Durable Promises; Cloudflare waitForApproval(). [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#core-capabilities-cross-cutting]
- Replay / time-travel debugging: Temporal replays Event History (+ replay tests as a CI guard); LangGraph replay + fork; DBOS workflow fork. Forking = re-run an agent from step N with edited state to debug prompts/tools. [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#core-capabilities-cross-cutting]
- Scheduling / cron / delays: Cloudflare schedule/scheduleEvery (DO alarms, self-rescheduling cron); durable sleep in Inngest/Trigger.dev/Vercel/Resonate; Temporal durable Timers. All survive restarts; long sleeps don't burn compute. [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#core-capabilities-cross-cutting]
- Concurrency & queues: DBOS durable queues with global/per-worker/per-tenant flow control; Hatchet fine-grained parallelism + priorities; Temporal task queues; Inngest/AgentKit concurrency + throttling on the function. [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#core-capabilities-cross-cutting]
Integration patterns
- Temporal - non-determinism goes in Activities: [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#integration-patterns]
- LangGraph - interrupt for human approval, resume by thread: [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#integration-patterns]
- Cloudflare - durable actor with cron + state: [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#integration-patterns]
- Inngest AgentKit - loop is orchestration, durability via the wrapper: [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#integration-patterns]
Selection / decision guidance
- Decide by where your workflow's boundary sits and who operates the control plane: [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#selection-decision-guidance]
- Already on Postgres, small team, workflow fits inside one DB boundary -> DBOS or Hatchet ("Postgres is enough"). Lowest infra; exactly-once is tightest when side effects share the same DB. Watch throughput ceiling + PG lock-in. [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#selection-decision-guidance]
- Cross-service / multi-tenant / multi-region / very-high fan-out, maturity matters -> Temporal. Pay the cluster ops cost; it earns its keep. [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#selection-decision-guidance]
- Agent IS naturally graph-shaped, you want first-class HITL + time-travel + versioned assistants -> LangGraph / LangSmith Deployment. [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#selection-decision-guidance]
- Edge / per-user stateful agent, WebSocket chat, zero-idle-cost, global -> Cloudflare Agents (Durable Objects). [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#selection-decision-guidance]
- Next.js / Vercel stack, want durability as a language directive, AI SDK integration -> Vercel Workflow. [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#selection-decision-guidance]
- TypeScript serverless, fastest onboarding, per-step pricing -> Inngest. [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#selection-decision-guidance]
- Unlimited task duration + mature self-host -> Trigger.dev v3. [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#selection-decision-guidance]
- Want lightweight durable execution + stateful entities, single binary -> Restate. [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#selection-decision-guidance]
- Tracking the frontier / distributed async-await model -> Resonate (not yet a production peer). [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#selection-decision-guidance]
- Rule of thumb: all of them will reliably persist your state. The real questions are language, who runs the control plane, migration cost in two years, and whether you need replay-determinism discipline (Camp 1) or are happy with snapshots (LangGraph) / actors (Cloudflare). [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#selection-decision-guidance]
Anti-patterns & failure modes
- Non-determinism in a replay workflow body. Date.now(), Math.random(), uuid(), direct HTTP/DB/LLM calls in a Temporal/Restate/Vercel/DBOS workflow -> NondeterminismError or silent drift on replay. Fix: move ALL I/O to steps/activities; use SDK replay-safe time/random. [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#anti-patterns-failure-modes]
- Changing workflow code while runs are in flight -> command/event mismatch. Use workflow versioning/patching and replay tests in CI. [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#anti-patterns-failure-modes]
- In-memory / non-durable checkpointer in production (LangGraph) -> state lost on restart; HITL interrupt() can't resume. Always back it with a DB. [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#anti-patterns-failure-modes]
- Holding a worker / socket / compute during a long human wait. Defeats the point and costs money. Use durable sleep / wait-for-token / interrupt so the platform evicts and re-queues (Hatchet, Trigger.dev, Inngest, Cloudflare keepAlive only for active work). [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#anti-patterns-failure-modes]
- Assuming replay/time-travel re-reads from cache. In LangGraph, nodes after the checkpoint re-execute (LLM/API/interrupt fire again). Budget for it. [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#anti-patterns-failure-modes]
- Non-idempotent side effects. Even with exactly-once intent, design tool steps to be idempotent (idempotency keys) - retries and recovery can re-enter the boundary. [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#anti-patterns-failure-modes]
- Unbounded event history / state growth on years-long runs -> use ContinueAsNew (Temporal) or equivalent; prune. [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#anti-patterns-failure-modes]
- Picking the heaviest platform for a 3-person team. Temporal's cluster is not a weekend project; don't adopt it for a single Postgres-centric service. [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#anti-patterns-failure-modes]
- Confusing the loop with the runtime. AgentKit Networks / LangGraph node wiring are loop design - see autonomous-loops. This skill is the durable substrate beneath them. [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#anti-patterns-failure-modes]
2025-2026 frontier
- First-party durable execution everywhere: AWS Durable Functions (Lambda), Cloudflare Workflows GA, Vercel Workflow - all shipped late 2025; durable execution is now table-stakes infra. [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#2025-2026-frontier]
- "Postgres is all you need" vs dedicated orchestrator is the live debate (DBOS/Hatchet vs Temporal). DBOS Go SDK + Databricks/Lakebase (Apr 2026) push the library-on-your-DB model. [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#2025-2026-frontier]
- Official agent-SDK integrations: Temporal x OpenAI Agents SDK (late 2025); DBOS x OpenAI Agents SDK; Vercel Workflow x AI SDK - durability wired directly under agent frameworks so tool calls become steps automatically. [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#2025-2026-frontier]
- Durable streams (Vercel getWritable(), Cloudflare): agent output survives the user closing the browser; reconnect resumes the stream. [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#2025-2026-frontier]
- Workflow forking as agent-debugging (DBOS, LangGraph): "git branch" a run from a checkpoint to reproduce and fix prompt/tool issues. [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#2025-2026-frontier]
- Maturity spread is wide: Temporal (battle-tested) -> Vercel/Cloudflare/Inngest (production, young) -> Resonate (v0.9.x, experimental). Calibrate accordingly. [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#2025-2026-frontier]
Sources
- Temporal - Workflow definition/determinism, put LLM/AI/API/DB calls in Activities: https://docs.temporal.io/workflow-definition , /workflows , /workflow-execution [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#sources]
- Temporal - durable AI agent tutorial: https://learn.temporal.io/tutorials/ai/durable-ai-agent/ [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#sources]
- LangGraph - persistence, interrupts, time-travel, assistants: https://docs.langchain.com/oss/python/langgraph/persistence , /interrupts , /use-time-travel , https://docs.langchain.com/langsmith/assistants [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#sources]
- LangGraph Platform GA / rename to LangSmith Deployment: https://www.langchain.com/blog/langgraph-platform-ga [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#sources]
- Cloudflare Agents - agent-class, long-running-agents, schedule-tasks, DO websockets: https://developers.cloudflare.com/agents/concepts/agent-class/ , /concepts/long-running-agents/ , /api-reference/schedule-tasks/ [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#sources]
- Inngest - durable steps for AI agents, durable workflows, AgentKit Networks: https://www.inngest.com/blog/ai-agents-inngest-durable-steps , https://www.inngest.com/uses/durable-workflows , https://agentkit.inngest.com/concepts/networks [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#sources]
- DBOS - architecture, postgres-is-all-you-need, durable agents + Databricks, Go-native, vs Temporal: https://docs.dbos.dev/architecture , https://www.dbos.dev/blog/postgres-is-all-you-need-for-durable-execution , https://www.dbos.dev/blog/building-durable-agents-dbos-databricks , https://docs.dbos.dev/explanations/comparing-temporal [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#sources]
- Hatchet - durable tasks: https://docs.hatchet.run/v1/durable-tasks , https://github.com/hatchet-dev/hatchet [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#sources]
- Trigger.dev v3 - no-timeout, CRIU, wait.* / waitpoints: https://trigger.dev/blog/v3-announcement , https://trigger.dev/docs/wait-for [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#sources]
- Restate - develop docs / virtual objects: https://docs.restate.dev/ [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#sources]
- Resonate - develop docs + repo (v0.9.1, Apr 2026, early): https://docs.resonatehq.io/develop , https://github.com/resonatehq/resonate [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#sources]
- Vercel Workflow - introducing-workflow, new-programming-model, docs: https://vercel.com/blog/introducing-workflow , https://vercel.com/blog/a-new-programming-model-for-durable-execution , https://vercel.com/docs/workflows [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#sources]
- 2025-2026 landscape/comparisons: https://www.tiarebalbi.com/en/blog/dbos-vs-temporal-postgres-durable-execution , https://reptile.haus/journal/durable-execution-ai-agents-temporal-restate-inngest-2026/ , https://agentmarketcap.ai/blog/2026/04/10/durable-agent-execution-production-temporal-modal-event-sourced [archived source: https://llms-explorer.com/sources/mdb-context-hub/durable-agent-execution/#sources]
Where this helps
- An agent workflow must survive a pod restart, deploy, or worker crash mid-run without losing the steps it already completed. [source] — AI-suggested, synthesized from this pack's existing facts — not extracted from a source document.
- A run needs to pause for human-in-the-loop approval and resume hours or days later without holding open a worker process, socket, or paid compute the whole time. [source] — AI-suggested, synthesized from this pack's existing facts — not extracted from a source document.
- A multi-step agent pipeline mixes long-running external calls (web scraping, batch LLM jobs) with short deterministic steps, and needs the whole sequence to be resumable as a unit. [source] — AI-suggested, synthesized from this pack's existing facts — not extracted from a source document.
- A team is choosing between Temporal-style deterministic replay, LangGraph-style state checkpoints, and Cloudflare-style durable actors, and needs the architectural axis that actually drives the decision. [source] — AI-suggested, synthesized from this pack's existing facts — not extracted from a source document.
Project ideas
- Build a long-running research agent on a deterministic-replay runtime (Temporal-style) where all I/O is isolated into Activities and the workflow body itself stays replay-safe. [source] — AI-suggested, synthesized from this pack's existing facts — not extracted from a source document.
- Build a HITL approval workflow using a state-checkpoint runtime (LangGraph-style) that persists the graph's state at every super-step and resumes cleanly from the last checkpoint after an approval. [source] — AI-suggested, synthesized from this pack's existing facts — not extracted from a source document.
- Build a durable-actor agent (Cloudflare Agents SDK style) that hibernates to zero compute between events and wakes on an HTTP request, WebSocket message, or scheduled alarm. [source] — AI-suggested, synthesized from this pack's existing facts — not extracted from a source document.
- Build a migration harness that replays a batch of recorded workflow event logs against a new runtime version to catch nondeterminism regressions before rolling it out. [source] — AI-suggested, synthesized from this pack's existing facts — not extracted from a source document.
Common mistakes
- Putting non-deterministic code (real I/O, random values, wall-clock reads) directly in a deterministic-replay workflow body instead of isolating it in an Activity — this triggers a NondeterminismError on replay. [source] — AI-suggested, synthesized from this pack's existing facts — not extracted from a source document.
- Assuming durable execution runtimes are interchangeable — Temporal's replay model, LangGraph's checkpoint model, and Cloudflare's durable-actor model make fundamentally different tradeoffs about compute cost while idle and what must stay deterministic. [source] — AI-suggested, synthesized from this pack's existing facts — not extracted from a source document.
- Skipping replay tests before deploying a workflow-code change, which is the main way a nondeterminism bug in a deterministic-replay system surfaces only in production. [source] — AI-suggested, synthesized from this pack's existing facts — not extracted from a source document.
- Choosing a runtime based on marketing framing rather than the actual axis that matters: whether the workload needs replay-from-start determinism, checkpoint-and-resume state, or an addressable always-on actor. [source] — AI-suggested, synthesized from this pack's existing facts — not extracted from a source document.
Known issues
- Deterministic-replay systems reconstruct state by re-executing the workflow function, so any change to the workflow's code path between a run's start and its resume can break replay of in-flight executions. [source] — AI-suggested, synthesized from this pack's existing facts — not extracted from a source document.
- State-checkpoint systems snapshot at every super-step, which can become expensive for very large agent state or very high step counts if snapshots aren't pruned or compacted. [source] — AI-suggested, synthesized from this pack's existing facts — not extracted from a source document.
- Durable actors consume zero compute while hibernated, but the wake latency on the next event is a real cost the deterministic-replay and checkpoint camps don't share in the same way. [source] — AI-suggested, synthesized from this pack's existing facts — not extracted from a source document.
- The space is still consolidating — several of the named runtimes (Resonate, Vercel Workflow, newer entrants) are explicitly called out as emerging, so API stability and long-term support vary a lot across the list. [source] — AI-suggested, synthesized from this pack's existing facts — not extracted from a source document.
Children
- Deterministic replay & event sourcing (frontier)
- Workflow-as-code / durable functions (frontier)
- Checkpointing & state persistence
- Human-in-the-loop interrupts & resume (frontier)
- Activities vs workflow body (non-determinism isolation) (frontier)
- Time-travel debugging & workflow forking (frontier)
- Durable sleep, timers & cron scheduling (frontier)
- Exactly-once side effects & idempotency (frontier)
- Durable actors & hibernation (Durable Objects) (frontier)
- Durable queues & concurrency flow control (frontier)
- Durable streams (reconnectable agent output) (frontier)
- Postgres-backed vs orchestrator-based durability (frontier)
Frontier under this node: Activities vs workflow body (non-determinism isolation), Deterministic replay & event sourcing, Durable actors & hibernation (Durable Objects), Durable queues & concurrency flow control, Durable sleep, timers & cron scheduling, Durable streams (reconnectable agent output), Exactly-once side effects & idempotency, Human-in-the-loop interrupts & resume, Postgres-backed vs orchestrator-based durability, Time-travel debugging & workflow forking, Workflow-as-code / durable functions