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

Your agent worked for 30 minutes, then the process died. What happens to the work?

TLDR: Most agent frameworks lose all progress on crash. Temporal (21k) and Inngest (5.5k) solve durable execution for generic workflows, but neither is agent-aware. The gap: agent-native event sourcing that handles non-deterministic LLM calls (cache the result, not the call), context window compression on replay, and scale-to-zero between bursts. Inngest AgentKit is the closest integrated solution today.

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.

Temporal Replay

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

Requirement	Temporal	Inngest	What’s missing
Survive process crashes	Yes	Yes	—
Resume at exact failure point	Yes	Yes	—
Scale to zero (no idle cost)	No	Yes	—
No separate server needed	No	Yes	—
LLM-call-aware checkpointing	No	No	Context window state
Tool schema integration	No	No	Typed, not opaque
Memory compression on replay	No	No	Don’t replay full history into LLM
Non-deterministic replay	Awkward	Basic	LLM calls return different results

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:

Event-Sourced State

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.

Previous: Agent Landscape #2: Orchestration — Pick Your Reasoning Loop Next: Agent Landscape #4: Memory — Beyond Context Window Overflow