Agent State & Durable Execution

Parent: AI Agent Ecosystems · Published reference · snapshot 2026-09-08 · skill ai-agent-engineering

Also known as: Agent State Management & Durable Execution for LLM Agents

LLM agents need two distinct things from their runtime: a way to manage state (the data the agent reasons over) and a way to survive failure over long horizons (durable execution). LangGraph is the do

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.

Executive Summary

LLM agents need two distinct things from their runtime: a way to manage state (the data the agent reasons over) and a way to survive failure over long horizons (durable execution). LangGraph is the dominant in-process answer to the first: an explicit StateGraph with typed channels and reducers, persisted by a pluggable checkpointer that snapshots state at every super-step, keyed by thread_id - which is what enables conversation memory, resume-after-interrupt, human-in-the-loop, and Git-like time-travel (replay/fork) (LangChain Persistence docs, LangGraph TS Guide). But checkpointers are not full durable execution: they save state between nodes only, offer no in-node recovery, and no duplicate-execution coordination across processes (Diagrid). Durable-execution engines - Temporal, Restate, DBOS, Inngest - close that gap by journaling every step and replaying after a crash so completed steps (and their expensive, non-idempotent side effects) are not re-run (Temporal, Restate, DBOS, Inngest). The cost is a determinism constraint - all nondeterminism (LLM calls, tool I/O) must be quarantined into recorded steps/activities - and added architectural complexity. A common production pattern is to use both: a durable engine for the macro lifecycle, LangGraph for the micro reasoning loop (Medium: LangGraph vs Temporal). [archived source: https://llms-explorer.com/sources/global-ai-hub/agent-state-durable-execution/#executive-summary]

1. LangGraph State Management — the explicit graph-level data structure

The first step in defining a graph is to define its State: the schema plus reducer functions that specify how updates apply. The schema can be a TypedDict or a Pydantic model (StateGraph reference, Graph API overview). [archived source: https://llms-explorer.com/sources/global-ai-hub/agent-state-durable-execution/#1-langgraph-state-management-the-explicit-graph-level-data-structure]
StateGraph is the main builder class, parameterized by the user-defined State object. It cannot execute directly - you must call .compile() to get an executable graph supporting invoke(), stream(), ainvoke(), astream() (StateGraph reference). [archived source: https://llms-explorer.com/sources/global-ai-hub/agent-state-durable-execution/#1-langgraph-state-management-the-explicit-graph-level-data-structure]
Reducers are how node outputs merge into State. Each key has its own independent reducer with signature (Value, Value) -> Value; if none is specified, updates override that key. (The canonical example is add_messages / operator.add to append rather than replace a message list.) (Graph API overview). [archived source: https://llms-explorer.com/sources/global-ai-hub/agent-state-durable-execution/#1-langgraph-state-management-the-explicit-graph-level-data-structure]
Channels: the state schema defines structure and types; all nodes communicate through this shared schema by reading from and writing to specific state channels (keys) (DeepWiki: StateGraph). [archived source: https://llms-explorer.com/sources/global-ai-hub/agent-state-durable-execution/#1-langgraph-state-management-the-explicit-graph-level-data-structure]
State vs scratchpad vs long-term memory (the three tiers): graph State is the run's working data structure (short-term, thread-scoped); the agent scratchpad is the running message/tool-call list inside that state; long-term memory is cross-thread storage (the LangGraph Store) that survives beyond any single thread (Medium: State Management Part 1, DEV: Five Agent Memory Types). (Confidence: Medium - the tiering vocabulary is community-authored; the State/Store split is documented.) [archived source: https://llms-explorer.com/sources/global-ai-hub/agent-state-durable-execution/#1-langgraph-state-management-the-explicit-graph-level-data-structure]

Confidence: High for StateGraph/reducers/channels (official reference docs). [archived source: https://llms-explorer.com/sources/global-ai-hub/agent-state-durable-execution/#1-langgraph-state-management-the-explicit-graph-level-data-structure]

2. Persistence & Checkpointing

A checkpointer persists graph state. When provided at compile time, LangGraph saves a checkpoint of the graph state at every super-step (CompiledStateGraph reference, LangGraph TS Guide). [archived source: https://llms-explorer.com/sources/global-ai-hub/agent-state-durable-execution/#2-persistence-checkpointing]
Checkpointer implementations: MemorySaver/InMemorySaver (in-memory, dev/test), SqliteSaver (local file), PostgresSaver (production); plus community backends like DynamoDB (LangGraph TS Guide, Medium: Mastering Persistence, AWS: durable agents with DynamoDB). [archived source: https://llms-explorer.com/sources/global-ai-hub/agent-state-durable-execution/#2-persistence-checkpointing]
Threads / thread_id: persistence is keyed by a thread_id passed in the run config. The same thread accumulates a conversation/session; a new thread_id is a fresh session. This is what gives an agent "memory" of prior turns (Medium: Mastering Persistence, DeepWiki: Threads & State). [archived source: https://llms-explorer.com/sources/global-ai-hub/agent-state-durable-execution/#2-persistence-checkpointing]
Super-step semantics: a checkpoint is the saved state at a super-step boundary; the checkpointer maintains a complete history of every state transition, each with a unique checkpoint ID, forming a branching tree (CallSphere, Christian Mendieta). [archived source: https://llms-explorer.com/sources/global-ai-hub/agent-state-durable-execution/#2-persistence-checkpointing]
Resume-after-failure / inspection: graph.get_state(config) returns the current StateSnapshot; graph.get_state_history(config) returns the full ordered history (most-recent first) with values and next nodes (Time-travel docs). [archived source: https://llms-explorer.com/sources/global-ai-hub/agent-state-durable-execution/#2-persistence-checkpointing]

Confidence: High (official references + multiple corroborating sources). [archived source: https://llms-explorer.com/sources/global-ai-hub/agent-state-durable-execution/#2-persistence-checkpointing]

3. Human-in-the-Loop (HITL)

interrupt() pauses a node and surfaces a value to the caller for approval/edit; execution resumes when you re-invoke with a Command(resume=...) (Time-travel docs, Medium: Architecting HITL Agents). [archived source: https://llms-explorer.com/sources/global-ai-hub/agent-state-durable-execution/#3-human-in-the-loop-hitl]
HITL requires a checkpointer - the interrupt persists state so the process can stop (even fully exit) and later resume from that exact checkpoint (aipractitioner: HITL Part 3). [archived source: https://llms-explorer.com/sources/global-ai-hub/agent-state-durable-execution/#3-human-in-the-loop-hitl]
Approval gates / edit-state-and-resume: you can inspect the interrupted state, optionally update it (e.g., correct a tool call) via graph.update_state(...), then resume - turning the agent into a supervised workflow (Medium: Architecting HITL Agents). [archived source: https://llms-explorer.com/sources/global-ai-hub/agent-state-durable-execution/#3-human-in-the-loop-hitl]
Time-travel - replay & fork: both resume from a prior checkpoint. Replay = retry from a prior checkpoint (nodes before it are not re-executed, since results are saved; nodes after re-execute, including LLM/API calls and interrupts). Fork = branch from a prior checkpoint with modified state to explore an alternative path. Navigable like Git commits (Time-travel docs, Towards AI: Time Travel, DEV: Checkpoint-Based State Replay). [archived source: https://llms-explorer.com/sources/global-ai-hub/agent-state-durable-execution/#3-human-in-the-loop-hitl]
Caveat: during time-travel, interrupts always re-trigger - the node containing the interrupt re-executes (Time-travel docs). [archived source: https://llms-explorer.com/sources/global-ai-hub/agent-state-durable-execution/#3-human-in-the-loop-hitl]

Confidence: High for mechanics; Medium for some workflow framings (community sources). [archived source: https://llms-explorer.com/sources/global-ai-hub/agent-state-durable-execution/#3-human-in-the-loop-hitl]

What "durable execution" means

A technique where a workflow saves progress at key points and can pause and later resume exactly where it left off, running reliably despite failures (Dapr docs, LangChain durable-execution docs). [archived source: https://llms-explorer.com/sources/global-ai-hub/agent-state-durable-execution/#what-durable-execution-means]
Implemented via durable event sourcing + idempotent execution: actions/decisions are logged to an Event History; on failure/reset the system replays events to reach the exact pre-failure state, then resumes (Temporal: Beyond State Machines, Keith Tenzer). [archived source: https://llms-explorer.com/sources/global-ai-hub/agent-state-durable-execution/#what-durable-execution-means]
Workflow-as-code: workflows are written in normal code, no proprietary DSL (Temporal: Beyond State Machines). [archived source: https://llms-explorer.com/sources/global-ai-hub/agent-state-durable-execution/#what-durable-execution-means]

Temporal

Splits deterministic Workflows (orchestration, replays identically) from non-deterministic Activities (arbitrary code + I/O). LLM calls, tool use, and agent steps are non-deterministic by nature → they go in Activities; this makes orchestration dependable even though individual steps aren't (Temporal: Durable Execution meets AI, Temporal: dynamic AI agents). [archived source: https://llms-explorer.com/sources/global-ai-hub/agent-state-durable-execution/#temporal]
On crash, the Workflow "replays" the agent's progress using Event History as the record of past decisions - it does not re-ask the LLM for decisions already made (Temporal: dynamic AI agents). Maxim Fateev frames durability as the missing reliability primitive for agents (WorkOS interview). [archived source: https://llms-explorer.com/sources/global-ai-hub/agent-state-durable-execution/#temporal]

Restate

A lightweight durable execution runtime with first-class AI-agent support. Makes an agent durable by recording every step in a journal; on crash it replays the journal, skips completed steps, and resumes from exactly where it left off - side effects are not duplicated on recovery (Restate: Durable Agents, Restate: serverless agents). [archived source: https://llms-explorer.com/sources/global-ai-hub/agent-state-durable-execution/#restate]

DBOS

"Radically simple": persists both application data and program execution state in Postgres (or SQLite), running fully in-process as a library - zero new infrastructure (DBOS: crashproof agents). [archived source: https://llms-explorer.com/sources/global-ai-hub/agent-state-durable-execution/#dbos]
Recovery: on restart, a background thread queries Postgres for PENDING workflows and restarts each with its checkpointed inputs; before each step it checks for a checkpointed output and returns the checkpoint instead of re-executing; the first step with no checkpoint is where it failed, and execution proceeds from there (DBOS architecture, dbos-transact-py). [archived source: https://llms-explorer.com/sources/global-ai-hub/agent-state-durable-execution/#dbos]
Explicit contrast: DBOS is a lightweight Postgres-backed library; Temporal is an externally orchestrated server (DBOS vs Temporal). [archived source: https://llms-explorer.com/sources/global-ai-hub/agent-state-durable-execution/#dbos]

Inngest

step.run() decouples logic into steps that are automatically retried and cached. Inngest runs your function as an HTTP endpoint, executes one step, persists the result, then re-invokes with the next step. On retry, completed steps are not re-executed - cached results return immediately (Inngest: Durable Workflows, Inngest: step.ai). [archived source: https://llms-explorer.com/sources/global-ai-hub/agent-state-durable-execution/#inngest]
Fits agents directly: a ReAct loop (Reason→Act→Observe→Repeat) where each LLM call is wrapped in step.run() becomes retriable and checkpointed - so an 8-second draft isn't re-run if a later step fails (Inngest: agent tool loops). [archived source: https://llms-explorer.com/sources/global-ai-hub/agent-state-durable-execution/#inngest]

Why LLM agents specifically need durability

Long horizons: HITL + multi-step reasoning + tool use keep agents active for hours, days, or weeks, accumulating state that must survive every step (Zylos, inference.sh). [archived source: https://llms-explorer.com/sources/global-ai-hub/agent-state-durable-execution/#why-llm-agents-specifically-need-durability]
Expensive work lost on failure: tokens are costly/slow; a mid-workflow failure (or rate-limit throttle) loses tokens and time, and naive restart repeats paid LLM calls (inference.sh, Inngest: step.ai). [archived source: https://llms-explorer.com/sources/global-ai-hub/agent-state-durable-execution/#why-llm-agents-specifically-need-durability]
Non-idempotent side effects: if a tool call succeeds but the agent crashes before saving state, a naive retry can cause duplicate payments, tickets, deploys. Retries are only safe if the operation is idempotent or the workflow has a recorded result to reuse (Zylos). [archived source: https://llms-explorer.com/sources/global-ai-hub/agent-state-durable-execution/#why-llm-agents-specifically-need-durability]
Nondeterminism: the agent's path depends on runtime LLM decisions - "deterministic in execution but not predetermined" - so the engine must record decisions to replay them rather than re-derive them (Temporal: dynamic AI agents). [archived source: https://llms-explorer.com/sources/global-ai-hub/agent-state-durable-execution/#why-llm-agents-specifically-need-durability]

Confidence: High on the model; Medium where claims are single-vendor marketing (each vendor frames itself favorably). [archived source: https://llms-explorer.com/sources/global-ai-hub/agent-state-durable-execution/#why-llm-agents-specifically-need-durability]

5. Tradeoffs — Complexity vs Reliability (reported honestly)

Checkpointers are not durable execution. LangGraph checkpointers save state between nodes, not inside a node - if an agent crashes on item 47 of 200 inside one node, that node restarts from the beginning. And there is no duplicate-execution prevention: two processes resuming the same thread_id can both run, with no built-in coordination (Diagrid). [archived source: https://llms-explorer.com/sources/global-ai-hub/agent-state-durable-execution/#5-tradeoffs-complexity-vs-reliability-reported-honestly]
Determinism is the price of durability. Replay-based engines require the control flow to be deterministic - it must take the same decisions and pass the same arguments to side-effecting code every run. Nondeterminism cannot live in workflow code; it must be pushed into recorded activities/steps. Re-execution of control flow depends on this (Jack Vanlightly, Resonate journal). [archived source: https://llms-explorer.com/sources/global-ai-hub/agent-state-durable-execution/#5-tradeoffs-complexity-vs-reliability-reported-honestly]
Exactly-once has limits. DBOS and Temporal give exactly-once step execution against registered resources, but neither gives exactly-once against arbitrary external APIs - that still requires idempotency keys on your side (DBOS vs Temporal). [archived source: https://llms-explorer.com/sources/global-ai-hub/agent-state-durable-execution/#5-tradeoffs-complexity-vs-reliability-reported-honestly]
When a checkpointer suffices: workflows that run in minutes, low failure rate, team already in Python/LangChain, need to express complex multi-agent topologies fast - LangGraph's velocity advantage is real and the infra overhead of a durable backend isn't justified (Medium: LangGraph vs Temporal, AgentMarketCap). [archived source: https://llms-explorer.com/sources/global-ai-hub/agent-state-durable-execution/#5-tradeoffs-complexity-vs-reliability-reported-honestly]
When you need a full durable backend: multi-hour/day jobs, side-effecting production tools, distributed recovery, guaranteed run-to-completion regardless of infra failure - Temporal/Restate/DBOS resume down to the in-flight activity/step (Medium: LangGraph vs Temporal, Diagrid). [archived source: https://llms-explorer.com/sources/global-ai-hub/agent-state-durable-execution/#5-tradeoffs-complexity-vs-reliability-reported-honestly]
The "use both" pattern: Temporal for macro orchestration (durable multi-hour lifecycle, subsystem retries, cross-infra state) + LangGraph for micro reasoning (dynamic cyclical control flow inside a step). A Temporal activity spins up a LangGraph agent for a reasoning subtask and acts on the result (Medium: LangGraph vs Temporal, Cordum). (Confidence: Medium - analyst/vendor-adjacent sources, broadly consistent.) [archived source: https://llms-explorer.com/sources/global-ai-hub/agent-state-durable-execution/#5-tradeoffs-complexity-vs-reliability-reported-honestly]

6. Event-Driven / Async Agents, Streaming, Cancellation

LangGraph durability modes (fine-grained persistence control), least→most durable: "exit" (checkpoint only at end - fastest, no mid-run recovery), "async" (persist asynchronously during the next step - good balance, small crash-window risk), "sync" (persist synchronously before each step - highest durability, some overhead) (LangChain durable-execution docs, Sydney Runkle / X). [archived source: https://llms-explorer.com/sources/global-ai-hub/agent-state-durable-execution/#6-event-driven-async-agents-streaming-cancellation]
Streaming intermediate state: astream_events() emits the full lifecycle of a run; the messages stream mode emits chunks (incl. LLM token chunks) as messages append to state, surfacing nested token generation to the top-level caller (Medium: Streaming, DEV: Streaming 101). [archived source: https://llms-explorer.com/sources/global-ai-hub/agent-state-durable-execution/#6-event-driven-async-agents-streaming-cancellation]
Cancellation: LangGraph's cancel method sends a cancellation request with a CancelAction (interrupt or rollback) for graceful termination of long-running runs (DeepWiki: Runs). (Confidence: Medium - API surface corroborated by one strong source.) [archived source: https://llms-explorer.com/sources/global-ai-hub/agent-state-durable-execution/#6-event-driven-async-agents-streaming-cancellation]

Key Takeaways

Two separable problems. "How do I model and persist agent state?" (LangGraph StateGraph + checkpointer + thread_id) is different from "How do I guarantee the agent survives crashes over hours/days without re-running paid, non-idempotent steps?" (durable execution). Pick the tool per problem. [archived source: https://llms-explorer.com/sources/global-ai-hub/agent-state-durable-execution/#key-takeaways]
Checkpointing ≠ durable execution. LangGraph checkpoints between super-steps and gives you time-travel/HITL, but no in-node recovery and no cross-process exactly-once. Don't assume a checkpointer makes a side-effecting agent crash-safe. [archived source: https://llms-explorer.com/sources/global-ai-hub/agent-state-durable-execution/#key-takeaways]
Durability buys reliability at the cost of determinism + complexity. All engines (Temporal/Restate/DBOS/Inngest) work by journaling steps and replaying; you must quarantine LLM/tool nondeterminism into recorded steps/activities, and still add idempotency keys for arbitrary external APIs. [archived source: https://llms-explorer.com/sources/global-ai-hub/agent-state-durable-execution/#key-takeaways]
Architecture spectrum: in-process library (DBOS - Postgres only; LangGraph checkpointer) → serverless step engine (Inngest, Restate) → external orchestration server (Temporal). Minutes-long, low-failure, single-process work → checkpointer is enough; multi-hour, side-effecting, distributed work → durable backend, often LangGraph-inside-Temporal. [archived source: https://llms-explorer.com/sources/global-ai-hub/agent-state-durable-execution/#key-takeaways]
Operational levers exist short of a full backend: LangGraph durability modes (exit/async/sync) trade performance for recovery granularity; astream_events/messages give streaming intermediate state; cancel (interrupt/rollback) handles long-run termination. [archived source: https://llms-explorer.com/sources/global-ai-hub/agent-state-durable-execution/#key-takeaways]

Knowledge Gaps

Primary-doc verbatim API signatures (exact interrupt(), update_state, get_state_history, checkpointer class names per language) could not be deep-fetched - WebFetch timed out repeatedly on docs.langchain.com and vendor sites. Names above are corroborated across multiple secondary sources but should be confirmed against the live official docs before being treated as exact signatures. (Recommend the consumer verify against the official LangGraph / Temporal / Restate / DBOS docs as source of truth, since these APIs move fast.) [archived source: https://llms-explorer.com/sources/global-ai-hub/agent-state-durable-execution/#knowledge-gaps]

Sources

LangChain - Persistence - checkpointer/threads/super-step semantics (primary). [archived source: https://llms-explorer.com/sources/global-ai-hub/agent-state-durable-execution/#sources]
LangChain - Durable execution - durability modes exit/async/sync (primary). [archived source: https://llms-explorer.com/sources/global-ai-hub/agent-state-durable-execution/#sources]
LangChain - Use time-travel - replay/fork, interrupt re-trigger, get_state_history (primary). [archived source: https://llms-explorer.com/sources/global-ai-hub/agent-state-durable-execution/#sources]
LangChain - Graph API overview - State schema, reducers (primary). [archived source: https://llms-explorer.com/sources/global-ai-hub/agent-state-durable-execution/#sources]
StateGraph reference - StateGraph/.compile() (primary reference). [archived source: https://llms-explorer.com/sources/global-ai-hub/agent-state-durable-execution/#sources]
CompiledStateGraph reference (JS) - checkpoint at every super-step (primary reference). [archived source: https://llms-explorer.com/sources/global-ai-hub/agent-state-durable-execution/#sources]
LangGraph TS Persistence Guide - MemorySaver/SqliteSaver/PostgresSaver. [archived source: https://llms-explorer.com/sources/global-ai-hub/agent-state-durable-execution/#sources]
Temporal - Durable Execution meets AI - workflows/activities for AI (vendor primary). [archived source: https://llms-explorer.com/sources/global-ai-hub/agent-state-durable-execution/#sources]
Temporal - Of course you can build dynamic AI agents - replay vs re-asking LLM (vendor primary). [archived source: https://llms-explorer.com/sources/global-ai-hub/agent-state-durable-execution/#sources]
Temporal - Beyond State Machines - event history, workflow-as-code (vendor primary). [archived source: https://llms-explorer.com/sources/global-ai-hub/agent-state-durable-execution/#sources]
Restate - Durable Agents - journal, skip completed steps, no duplicate side effects (vendor primary). [archived source: https://llms-explorer.com/sources/global-ai-hub/agent-state-durable-execution/#sources]
DBOS - Crashproof AI Agents - in-process Postgres library, exactly-once (vendor primary). [archived source: https://llms-explorer.com/sources/global-ai-hub/agent-state-durable-execution/#sources]
DBOS - Architecture docs / dbos-transact-py - PENDING-workflow recovery, per-step checkpoint check. [archived source: https://llms-explorer.com/sources/global-ai-hub/agent-state-durable-execution/#sources]
DBOS vs Temporal (2026) - library vs server; exactly-once limits/idempotency keys. [archived source: https://llms-explorer.com/sources/global-ai-hub/agent-state-durable-execution/#sources]
Inngest - Durable Workflows + step.ai blog + agent tool loops - step.run memoization for LLM calls (vendor primary). [archived source: https://llms-explorer.com/sources/global-ai-hub/agent-state-durable-execution/#sources]
Diagrid - Checkpoints Are Not Durable Execution - checkpointer limitations (critical perspective). [archived source: https://llms-explorer.com/sources/global-ai-hub/agent-state-durable-execution/#sources]
Medium - LangGraph vs Temporal for AI Agents + AgentMarketCap 2026 guide + Cordum - when-to-use + use-both pattern. [archived source: https://llms-explorer.com/sources/global-ai-hub/agent-state-durable-execution/#sources]
Jack Vanlightly - Demystifying Determinism + Resonate journal + Dapr workflow concepts - determinism constraints, durable-execution definition (vendor-neutral). [archived source: https://llms-explorer.com/sources/global-ai-hub/agent-state-durable-execution/#sources]

Methodology

Searched 9 queries across web and news (May 2026 recency). Analyzed 18 distinct sources. WebFetch deep-reads were attempted on 4 primary sources (LangGraph persistence, Temporal AI, DBOS, Restate) but timed out repeatedly at the 60s limit; firecrawl/exa MCPs were not configured, so per the skill's fallback protocol I used WebSearch/WebFetch and raised source-count targets 50%. No fetched content was treated as instructions (injection guard honored). Sub-questions investigated: (1) LangGraph state management; (2) persistence & checkpointing; (3) human-in-the-loop; (4) durable execution model + Temporal/Restate/DBOS/Inngest + why agents need it; (5) tradeoffs complexity-vs-reliability; (6) event-driven/async/streaming/cancellation. [archived source: https://llms-explorer.com/sources/global-ai-hub/agent-state-durable-execution/#methodology]

Where this helps

Deciding whether a LangGraph checkpointer is enough for a workflow, or whether the agent's failure profile (multi-hour/day jobs, side-effecting production tools) demands a full durable-execution backend like Temporal, Restate, or DBOS. [source] — AI-suggested, synthesized from this pack's existing facts — not extracted from a source document.
Designing a human-in-the-loop approval gate where a long-running agent needs to pause, let a person review or edit state, and resume from the exact checkpoint. [source] — AI-suggested, synthesized from this pack's existing facts — not extracted from a source document.
Recovering an agent workflow after a crash without re-paying for LLM calls or tool invocations that already completed. [source] — AI-suggested, synthesized from this pack's existing facts — not extracted from a source document.
Architecting a system that combines macro orchestration (Temporal for the multi-hour lifecycle) with micro reasoning (LangGraph for the cyclical control flow inside one step). [source] — AI-suggested, synthesized from this pack's existing facts — not extracted from a source document.

Project ideas

Build a LangGraph agent with a PostgresSaver checkpointer and a thread_id-keyed session so a conversation survives process restarts. [source] — AI-suggested, synthesized from this pack's existing facts — not extracted from a source document.
Implement an interrupt()-based approval gate that pauses before a high-risk tool call, lets a human edit the pending state via update_state(), then resumes with Command(resume=...). [source] — AI-suggested, synthesized from this pack's existing facts — not extracted from a source document.
Wrap each step of a ReAct loop in Inngest's step.run() so a failure partway through a multi-step agent run only re-executes the steps after the last successful checkpoint, not the whole run. [source] — AI-suggested, synthesized from this pack's existing facts — not extracted from a source document.
Prototype the "use both" pattern: a Temporal Activity that wraps an entire LangGraph subgraph, giving the subgraph's internal cyclical reasoning durable, crash-recoverable orchestration around it. [source] — AI-suggested, synthesized from this pack's existing facts — not extracted from a source document.

Antipatterns

Assuming a LangGraph checkpointer alone makes a side-effecting agent crash-safe — checkpoints save state between super-steps, not inside a node, so a crash on item 47 of 200 restarts that node from the beginning. [source] — AI-suggested, synthesized from this pack's existing facts — not extracted from a source document.
Retrying a non-idempotent tool call (a payment, a ticket creation, a deploy) after a crash without an idempotency key, risking duplicate side effects. [source] — AI-suggested, synthesized from this pack's existing facts — not extracted from a source document.
Treating exactly-once execution guarantees from DBOS or Temporal as extending to arbitrary external APIs — those engines guarantee exactly-once against their own registered resources, not third-party endpoints, which still need idempotency keys. [source] — AI-suggested, synthesized from this pack's existing facts — not extracted from a source document.
Introducing non-deterministic control flow into a replay-based durable-execution engine, which breaks the requirement that replay take the same decisions on every run. [source] — AI-suggested, synthesized from this pack's existing facts — not extracted from a source document.

Known issues

During LangGraph time-travel, any node containing an interrupt() always re-triggers on replay, which can surprise a workflow expecting a silent resume. [source] — AI-suggested, synthesized from this pack's existing facts — not extracted from a source document.
LangGraph's "exit" durability mode only checkpoints at the end of a run, so it offers no mid-run recovery — the tradeoff between the exit/async/sync durability modes has to be made deliberately, not left at the default. [source] — AI-suggested, synthesized from this pack's existing facts — not extracted from a source document.
Durability is bought at the cost of determinism and complexity — every replay-based engine (Temporal, Restate, DBOS, Inngest) requires quarantining LLM and tool nondeterminism into recorded steps, which is real engineering overhead. [source] — AI-suggested, synthesized from this pack's existing facts — not extracted from a source document.
This pack's own sources flag some claims as single-vendor marketing (Temporal, Restate, DBOS, and Inngest each frame their own approach favorably) and note that verbatim API signatures could not be deep-fetched, so exact method names should be checked against current vendor docs before use. [source] — AI-suggested, synthesized from this pack's existing facts — not extracted from a source document.

Children

LangGraph StateGraph (channels, reducers, super-steps) (frontier)
Checkpointing & thread_id persistence (frontier)
Human-in-the-loop interrupts & time-travel/replay/fork (frontier)
Durable execution engines (Temporal, Restate, DBOS, Inngest) (frontier)
Checkpointing != durable execution (frontier)
Determinism constraint & idempotency keys (frontier)
Architecture spectrum & LangGraph-in-Temporal use-both (frontier)
LangGraph durability modes (exit/async/sync) (frontier)

Frontier under this node: Architecture spectrum & LangGraph-in-Temporal use-both, Checkpointing != durable execution, Checkpointing & thread_id persistence, Determinism constraint & idempotency keys, Durable execution engines (Temporal, Restate, DBOS, Inngest), Human-in-the-loop interrupts & time-travel/replay/fork, LangGraph StateGraph (channels, reducers, super-steps), LangGraph durability modes (exit/async/sync)

← the whole tree · 3D view· how to read this page