Restate
Durable Execution as the Runtime’s Missing Piece
The one guarantee every agent runtime needs and almost none of them ship
The most dangerous failure mode in an agent runtime is not a bad tool call. It is a crash on step 37 of a 50-step workflow with no way to resume from step 36.
Every agent that runs long enough hits this. The LLM call times out. The tool invocation hangs. The process gets OOM-killed by a watchdog that noticed the agent had been running for 47 minutes. When the runtime restarts, the agent begins again from the beginning, re-executing every expensive step it already completed, duplicating side effects, and burning tokens on work that was already done. If the workflow involved sending an email or creating a database record, the duplicate is now a correctness bug, not just a waste of tokens.
Hermes Agent solves this with checkpointing and rollback: the runtime takes a snapshot after each turn, persists it to storage, and resumes from the last good checkpoint on restart. OpenClaw does something similar with its event journal: every input, tool call, and LLM response is logged as an immutable event, and replaying the journal reconstructs the agent’s state. Both approaches work. Both took significant engineering effort to build. Both are tightly coupled to their specific runtime architecture.
Restate asks a different question: what if durable execution was not something every runtime had to build from scratch?
Restate is a durable execution engine. It treats application code as a state machine and guarantees completion. When your code calls Restate to execute a workflow and the process crashes on step 37, Restate resumes from the last completed step, not from the beginning. It does this through a journaling mechanism that records every completed step, every side effect, and every result. On restart, it replays the journal, skips everything that already finished, and picks up exactly where it left off. The application code does not need to know this is happening. It writes a regular function, and Restate makes that function survive process death.
The primitive is simple. You define a handler, you register it with Restate, and you invoke it. Restate manages the lifecycle: retry with backoff on transient failures, exactly-once delivery semantics, and deterministic replay of completed steps. If your handler sleeps for 24 hours waiting for a human approval and the server restarts twice during that window, Restate wakes up, replays the journal, and resumes waiting. The handler never knows the server restarted.
For agent runtimes, this is the missing piece that almost none of them ship natively. Hermes has it, built into the runtime’s checkpoint layer. OpenClaw has it, built into the event journal. Every other framework, from LangGraph to CrewAI to AutoGen, either delegates persistence to the developer or provides a lightweight in-memory implementation that does not survive a restart. The developer gets a checkpointer interface and a “bring your own database” instruction. What should be a platform guarantee becomes an implementation exercise.
Restate changes the calculus. Instead of building durable execution into your agent framework, you can put Restate between your framework and the world and get it for free. Your LangGraph agent becomes a Restate handler. Each turn through the agent loop is a step in the Restate journal. When the agent crashes, Restate resumes from the last completed turn, with the LLM response, tool outputs, and state mutations all preserved. The agent framework does not need to know this is happening.
The architecture is worth understanding because it makes explicit what most runtimes do implicitly. Restate runs as a sidecar or a standalone service. Your application code invokes Restate via an SDK (TypeScript, Java, Python, Go, or Rust), and Restate manages execution. Each invocation gets a journal: an append-only log of every deterministic operation the handler performed, including RPC calls to other services, state mutations, and the results of those operations. When the handler runs, every non-deterministic operation (a random number, a timestamp, an external API call) is recorded in the journal alongside its result. On replay, Restate reads the result from the journal instead of re-executing the operation. The handler sees a consistent world. The journal is the truth.
This is the same mechanism Temporal uses, which is why comparisons are inevitable. Temporal is the incumbent in the durable execution space: a mature, battle-tested platform with the largest community, the most configurability, and the steepest learning curve. Restate is the simpler alternative. It does not require learning Temporal’s workflow DSL or configuring 14 different timeout parameters. It treats your code as code, not as a workflow definition that must be compiled into a Temporal task. You write a function, annotate it, and register it. Restate handles the rest.
The tradeoff is real. Temporal gives you more control: custom retry policies, explicit activity heartbeating, namespace-level isolation, and a query system for inspecting running workflows. Restate gives you simplicity: fewer concepts, no DSL, and a programming model that feels like writing regular application code. For teams that need the full power of Temporal’s workflow engine, Temporal is the right choice. For teams building agent runtimes that need durable execution without adopting a platform that will reshape their architecture, Restate is the more natural fit.
The version story matters because it tells you whether the project is healthy. At this writing, the Restate server is at v1.7.2, released July 6, 2026. The TypeScript SDK shipped v1.16.4 on August 4, two days ago. The project has 4,256 stars on GitHub and a steady release cadence. It is written in Rust for the server core, with SDKs that feel native to each language ecosystem. This is not a project that shipped a 0.1 and went quiet. It is actively maintained, with the SDK layer moving faster than the server layer, which is the pattern you want to see: the stable core evolves deliberately while the developer-facing surface iterates quickly.
The Python SDK tells a more nuanced story. The PyPI package sits at v0.11.6, last updated in October 2025. This does not mean Restate is neglecting Python. It means the TypeScript and Java SDKs are the primary development surfaces, and the Python SDK lags. For Python-first agent stacks, this is a real limitation. The SDK works, but it is not at feature parity with TypeScript, and the gap is measured in months, not weeks. If your agent runtime is Python, the Restate integration path is through the TypeScript server with a Python client, which adds an extra hop. It is not a dealbreaker, but it is worth knowing before you architect around it.
The other limitation is operational. Restate is a service you run. It needs its own process, its own storage (RocksDB or Postgres), and its own monitoring. For a solo developer running a personal agent on a laptop, adding a second service to the stack feels like overkill. Hermes Agent’s built-in checkpointing or OpenClaw’s event journal solve the same problem without an external dependency. The question is whether you want durability to be a property of your runtime or a property of your infrastructure. Restate makes it a property of your infrastructure, which is the right answer at scale and the wrong answer for a single-machine setup.
Where Restate fits in the agent runtime landscape is as a composable primitive. If you are building your own runtime on LangGraph, or extending CrewAI with custom persistence, or designing a multi-agent system where each agent’s progress must survive process boundaries, Restate is the layer that gives you durable execution without building it yourself. You wrap each agent turn in a Restate handler, and Restate guarantees that turn will complete or resume from where it left off. The agent framework handles the reasoning. Restate handles the reliability. The separation of concerns is clean.
The project is also worth watching for a reason beyond its immediate utility. The durable execution space is consolidating around a few patterns: journal-based replay (Restate, Temporal, DBOS), event-sourcing (OpenClaw’s model), and checkpointing (Hermes’s approach). Restate represents the simplest implementation of the journal-based pattern, and there is value in understanding the simplest version before reaching for the full platform. If you read the Temporal docs and felt like you needed a PhD in distributed systems, Restate is the architecture that makes the same guarantees with a fraction of the concepts.
The agent runtime ecosystem is still figuring out where durable execution belongs. Hermes builds it in. OpenClaw builds it in. Restate provides it as a service. Each approach has a different answer to the same question: who is responsible for making sure the agent finishes what it started? The answer depends on your architecture, but the question is not optional. An agent that cannot survive a crash is a script, not a runtime. Restate makes survival a service you can plug in, instead of a subsystem you have to build.
If this was useful, forward it to one engineer who needs less noise in their feed.