Agents are becoming long-running, asynchronous processes, so their infrastructure needs durable execution, session isolation, communication, and control.
2
Restate journals events from an agent and replays them after failure, allowing a run to continue from its failure point instead of starting again.
3
Virtual objects let applications interact with a live agent session, inject relevant information, or cancel and rewind work down the call chain.
Summary
Giselle van Dongen focuses on the infrastructure around agents rather than the agent loop itself. She argues that long-running, stateful, distributed agents need durable execution, consistent session state, communication between processes, and control over work already in progress. Restate runs in front of an agent service, keeps a connection open, and records the agent's events in a journal. After a failure, it replays that journal to recover the process at the point where it stopped. The demo uses a deep research agent in Slack. A planner creates subtopics, parallel agents perform research, and a failed web search retries successfully. Van Dongen also shows human approval that can suspend a function for weeks or a month without consuming serverless execution time. Restate's virtual objects model sessions as isolated stateful entities. A live session can receive new context, continue with it, or cancel and rewind its current work. The underlying system uses a push-based distributed log.
Agents are becoming persistent processes that need a different infrastructure layer
Van Dongen describes three waves of interaction with language models. First, an LLM answers a question like a website. Then an agent runs on a computer with tools and user interaction. The next stage is a persistent, asynchronous process that runs in infrastructure, accesses tools and other agents, and keeps context. As systems move from individual agents to platforms connecting parts of an organization, teams need infrastructure for the distributed pieces. Agent SDKs and memory help people start quickly, but they do not handle the connections between those pieces.
A durable agent foundation needs recovery, isolation, communication, and control
Restate provides four parts of the foundation. Durable execution lets a run that lasted a week recover after a crash at the point where it failed instead of restarting. Session handling supports many concurrent runs while keeping their state consistent and preventing agents from interfering with each other. The system also supports communication between agents, MCP servers, and other tools. Finally, it provides control, including the ability to cancel an agent that is stuck or doing work it should stop.
Restate turns an ordinary handler into a journaled, recoverable process
Restate runs as a server in front of the agent service, similar to a proxy or message broker. It pushes a request to the service and maintains an open connection that Van Dongen compares to a lifeline. As the agent works, it sends events to Restate. The server uses the resulting journal to recover the process after failure. In code, HTTP handlers become durable through the Restate SDK. Wrapping an operation in restate.run records the step so a failure later can return execution to that exact point.
Journaled steps make retries continue from existing progress
The demo is a research agent connected to Slack. A planner creates a list of subtopics, and approval starts parallel research agents before a writer produces the report. Van Dongen injects a tool error into one sub-agent. A web search fails because its API is down, then retries and completes successfully. The journal preserves the work that already finished, so the run does not begin again from the start.
Human approval can suspend a function without holding serverless execution time
A durable promise gives a workflow a suspension point while it waits for a human. The approval may take weeks or a month, and the process can survive restarts and redeploys during that period. When the person clicks the approval button in Slack, the promise is unblocked and the function continues from where it stopped. While it is suspended on serverless infrastructure, it does not consume execution time on the function.
Virtual objects isolate each agent session and serialize its work
Van Dongen models a long-lived agent as a virtual object rather than only as a workflow. Each object has a unique identifier, such as a session ID, isolated key-value state, and handlers for durable functions. This lets a user send follow-up context to a research session while it is still running. Restate also ensures that only one execution for a session runs at a time. A second execution waits behind the current one instead of overwriting its state.
A running session can accept relevant context or switch to a new task
An execution has a unique identifier that other processes can use to retrieve its output, cancel it, or signal it. In the demo, a controller asks an LLM whether new input is relevant to the current research. The message "focus on frontier models" is judged relevant and is injected into the live loop. When the user says to forget that research and work on AI policy, the controller cancels the current run and starts a new one.
Cancellation propagates down the call chain and rewinds active work
When the research topic changes, cancellation is sent down the stack. If the controller has already started sub-agents, those sub-agents are cancelled first, followed by the controller. Van Dongen describes this as rewinding the stack. The model gives agents a way to roll back work that is no longer wanted instead of leaving earlier calls running after the user has changed direction.
The distributed log uses pushed invocations to reduce workflow latency
Restate's internal design has clients, services, a log that persists journal events, and an event loop. Depending on an event, the loop persists state, sets a timer, or sends a request to another agent. Unlike workflow systems that poll for new tasks, Restate pushes invocations. Van Dongen says this gives lower latency and reports 45 milliseconds at p99 for a 10-step workflow. The system includes an embedded state store, runs as a single binary, and can be replicated with snapshots to object storage.
