Agents need checkpoints the way databases need write-ahead logs
No database engineer would ship an engine that loses committed transactions when the process dies. Yet most agent systems I review do exactly that: forty minutes into a multi-step run, a pod gets rescheduled, and everything — the LLM calls already paid for, the tools already invoked, the human approval already granted — evaporates. Durable execution is to agents what the write-ahead log is to databases: not an optimization you add when scale demands it, but the mechanism that makes the system's core promise honest.
The analogy is structural, not decorative. A WAL records intent before effect, so recovery means replaying the log, not reconstructing lost state from guesswork. Temporal's event history works the same way: an append-only log of ExecutionStarted, ActivityCompleted, TimerFired, SignalReceived events that serves as the single source of truth for a workflow. When a worker crashes, the platform replays the history against the workflow code and resumes exactly where it stopped — completed activities are not re-executed, they're memoized from the log. LangGraph makes the identical move at graph granularity: a checkpointer writes the full serialized state after every super-step, keyed by thread ID, and resuming is just supplying a checkpoint ID. Different frameworks, one idea — persist the decision log, derive the state.
Why does this rise to architectural requirement rather than nice-to-have? Because agent work is long-running by nature and failure-prone by environment. A workflow that waits on a human-in-the-loop signal might sleep for three days; a rate-limited provider can stall a step for minutes; a redeploy happens whenever it happens. Anything that spans more than one request lifetime will eventually collide with process death. The naive alternatives all fail in characteristic ways: retry-from-scratch re-executes side effects and re-bills every token; keeping conversation state only in the LLM provider's thread — a genuine anti-pattern — marries your recovery story to someone else's retention policy; in-memory checkpointers like LangGraph's MemorySaver are explicitly development-only and vanish with the process, which is why the production path runs through SqliteSaver to PostgresSaver with advisory locks and connection pooling.
The log is the contract
Durability comes with obligations, and this is where teams discover it's an architecture, not a library import. Replayed workflow code must be deterministic — same inputs plus same history must yield the same command sequence, or Temporal throws a nondeterminism error mid-recovery. Side effects need idempotency keys (workflow run ID plus activity ID is the standard derivation) so an at-least-once retry doesn't double-charge a customer. Long activities must heartbeat so liveness failures are detected. Unbounded histories need continue-as-new. State schemas need versioning, because a checkpoint written by last month's code will be read by next month's. None of this is exotic — it's the same replay-safety discipline event-sourced systems have practiced for years — but you cannot retrofit it after the agent is live, any more than you can bolt a WAL onto a database that already lost the data.
The honest caveat: durable execution is not a reliability panacea, and the durability literature itself is explicit about what it does not fix — hallucination, runaway loops, and eval drift all survive checkpointing perfectly intact. A faithfully replayed bad decision is still a bad decision. And for short, cheap, stateless tasks — a single-shot classification, a stateless summarize call — retry-from-scratch is genuinely fine; the determinism constraints and serialization headaches (generators, closures, live client objects don't checkpoint) are a real tax that a five-second task shouldn't pay.
But the moment an agent's work outlives a request — multi-step tool chains, human approvals, anything with a timer — the question stops being whether to checkpoint and becomes only where the commit points go. Whether you buy that from Temporal, Restate, DBOS, or Inngest, or assemble it from LangGraph checkpointers and an event-sourced state model, the architecture is the same shape. Databases settled this argument decades ago. Agents are just the newest workload to relearn it.