Building interruption-tolerant agents with durable execution with Dominik Tornow at Resonate HQ

Durable execution is a programming approach where code is written in an interruption-agnostic way but executed in an interruption-tolerant manner. In practice, this means engineers can write standard sequential code without worrying about failures or pauses, and the underlying framework ensures the execution survives crashes, restarts, or long wait times without losing progress.

When AI agents move into enterprise environments and run autonomously for hours or days, they become distributed systems problems. Agents call tools, kick off data pipelines, and invoke other agents, creating complex call graphs. If a connection drops or a process crashes mid-workflow, traditional retry logic means restarting everything from scratch. With LLM calls and data pipelines that can cost thousands of dollars per run, that's not viable. Durable execution lets these workflows survive interruptions and resume where they left off.

A failure is involuntary, like a server crash or a dropped TCP connection. An interruption is a broader concept that includes both involuntary failures and voluntary pauses, such as an agent deliberately sleeping for a week or waiting for an external event. Designing for interruption tolerance covers both cases, making the system more resilient overall.

A durable promise is a coordination and recovery mechanism with a stable, externally addressable identity (essentially a URL). It represents a point in a distributed call graph. If a process restarts, it can rejoin an existing durable promise instead of re-triggering the underlying computation. It also enables hard suspension: an agent can go away entirely while waiting, then resume when the promise resolves.

Both address state management in distributed systems, but they present very different programming models. Actors work well when a single message can be fully processed within one activation. But when an actor triggers something external and needs to wait, engineers end up building manual state machines and managing control flow themselves. Durable execution preserves a sequential programming model where control flow is handled for you, making complex workflows (nested try/catch blocks, loops, conditional branching) much simpler to write and reason about.

In traditional microservices, each function call is cheap and fast, so retrying from the top after a failure is no big deal. With agents, LLM calls burn through expensive tokens, and tools may trigger data pipelines that cost tens of thousands of dollars. Blindly retrying everything below the failure point wastes significant time and money. Durable execution enables fine-grained recovery so only the failed step needs to be addressed.

‍

‍

‍

‍

‍

‍

There are two distinct challenges. The agentic challenge is balancing autonomy with alignment: giving agents enough freedom to be useful while ensuring they stay within governance, security, and compliance boundaries. The distributed systems challenge is making multi-agent workflows reliable, observable, and recoverable across long-running, expensive operations. Durable execution addresses the second challenge but not the first.

Yes. Because durable execution decouples an agent's identity from its physical process, the agent doesn't need to stay pinned to a specific machine or TCP connection. It can run on serverless functions, suspend when waiting on long-running tasks, and resume on a completely different server once the result is ready.