Agent Landscape #3: Durability — Why Your Agent Can't Survive a Restart

The Problem

Your agent has been running a cloud migration for 30 minutes. It's provisioned 3 databases, migrated 2 schemas, and is about to run the final data sync. Then the container gets restarted for a deploy.

What happens?

• With most frameworks: all progress lost. The agent starts from scratch. It might re-provision the databases (duplicates). It might fail because resources already exist (errors). Or it might not know where it stopped (inconsistent state).

• The user spent 30 minutes watching progress, then gets "something went wrong, please try again."

This isn't hypothetical. Every long-running agent hits this. The causes: OOM kills, deploys, network partitions, spot instance preemptions, and just process crashes.

The only solution is durable execution — persisting every agent action so recovery is replay, not restart.

Research & Industry Context

Key Papers & Concepts

Deterministic Replay (Temporal, 2020) — record the outcome of every non-deterministic operation (I/O, timers, external calls). On crash, replay the workflow from the event log — cached outcomes return instantly, execution resumes at the exact failure point.

CriticGPT (OpenAI, 2024) — demonstrated that LLM outputs are inherently non-deterministic and need to be treated as cached side effects, not replayable computations. This is why traditional event sourcing doesn't directly apply to agents.

Agent Workflow Memory (Microsoft Research, 2024) — introduces reusable workflow memories extracted from successful agent trajectories. Agents store and retrieve past execution patterns to avoid re-solving similar tasks from scratch — directly applicable to checkpoint-and-resume strategies.

Trial and Error (Qiao et al., 2024) — agents that learn from execution failures via experience replay. Failed trajectories are stored and used to avoid repeating mistakes — complementary to durability (don't just survive crashes, learn from them).

Claude Code's conversation compaction — when context grows too long, summarize earlier turns while preserving key decisions and tool results. A practical solution to the "replay 10,000 events into a context window" problem.

How Industry Solves This

Anthropic (Claude Code): Conversation compaction — when context nears limits, earlier turns are summarized while preserving tool results and key decisions. Not full event sourcing, but practical durability for interactive sessions.

OpenAI (Assistants API): Thread-based persistence — messages and tool results stored server-side. Resume by loading the thread. Simple but opaque (no event log you can inspect or replay).

Temporal users building agents: Wrap each LLM call as an Activity. The LLM response is cached in the event log. On replay, the cached response returns without re-calling the LLM. Works but adds boilerplate.

Inngest AgentKit: Step-level caching designed for agent loops. Each tool call is a step; crash recovery replays from the last cached step. Closest to agent-native durability in production.

Replit Agent: Checkpoint-based — saves full agent state at key decision points. Resume from last checkpoint. Loses inter-checkpoint progress.

Open Source Solutions

Three projects dominate durable execution, but none were built for agents.

Temporal — 21k stars

What it is: The gold standard for durable workflow execution. Workflows are normal code. Temporal guarantees every workflow runs to completion by recording every decision in an event-sourced history.

Strengths:

• Most battle-tested durability guarantee (Stripe, Netflix, Snap, Coinbase)

• Event-sourced execution history — functionally identical to what agents need

• Language-agnostic with strong SDK support

• Self-hostable or managed (Temporal Cloud)

Limitations for agents:

• Not agent-aware — no concept of tool schemas, LLM calls, or context windows

• Requires running a Temporal Server (operational overhead)

• Deterministic workflow constraint is awkward for LLM calls (inherently non-deterministic)

• Steep learning curve (signals, queries, activities, child workflows)

Key insight: Temporal proves event-sourced execution history is the right pattern. But wrapping every LLM call as a Temporal Activity adds friction that agent developers shouldn't need.

Inngest — 5.5k stars

What it is: Workflow orchestration platform for stateful step functions and AI workflows. Runs on serverless, servers, or the edge. Handles retries, scheduling, and step-level state persistence.

@inngest.function(trigger=inngest.TriggerEvent("agent/task.started"))
async def run_agent(step):
    plan = await step.run("plan", lambda: llm.plan(task))
    for action in plan.actions:
        result = await step.run(f"execute-{action.id}", lambda: execute(action))
    return await step.run("summarize", lambda: llm.summarize(results))

Each step.run() is individually cached. Crash at step 5 → restart from step 5.

Strengths:

• Serverless-native — works with Lambda/Cloud Run, not instead of them

• Step-level durability without a separate orchestration server

• Simple mental model ("functions that don't fail")

Limitations for agents:

• Not agent-aware (same gap as Temporal)

• Step granularity is coarse for agent loops

• Primarily TypeScript-focused

• Managed service (less self-hostable)

Key insight: "Step-level durability in serverless" is exactly right for agents. Each tool call result persisted like a step. Resume from last persisted point.

Why Pipeline Orchestrators Don't Fit

Airflow / Prefect (23k) / Dagster are designed for batch data pipelines:

• Schedule-driven (cron), not event-driven (user message)

• DAG-based (static graph), not iterative (reason → act → observe → loop)

• Batch-oriented, not interactive

• No concept of sessions, conversations, or memory

Agents are the opposite: interactive, iterative, long-lived, and user-driven.

The Gap: What Agents Actually Need

Agents need event-sourced state (like Temporal) that's agent-native (understands LLM calls, tool schemas, context windows, and memory).

Pattern: Event-Sourced Agents

The ideal model combines Temporal's event history with agent-specific semantics:

Every event persisted the instant it happens. No checkpoint gaps. Crash recovery is replay + continue.

Key Takeaway

Durable execution is a solved problem for generic workflows. For agents, the additional requirements are:

• LLM calls are non-deterministic (cache the result, not the call)

• Context windows have limits (compress on replay, don't feed 10k events to the LLM)

• Tool calls have schemas (validate on resume)

• Sessions span hours (scale to zero between bursts)

The practical path today: Temporal or Inngest for the durability primitive, combined with agent-specific replay logic (context compaction, tool result caching). Inngest AgentKit is the closest to an integrated solution.