Dominik Tornow
Conference affiliation: Resonate HQ, Inc · 2026
Related work and projects
- Think Distributed Systems ↗manning.com · Source ↗
- The CAP Theorem. The Bad, the Bad, & the Ugly ↗dtornow.com
- async-await-mechanics ↗github.com · Source ↗
- fossasia-summit-2024 ↗github.com · Source ↗
- minimal-distributed-async-await ↗github.com · Source ↗
- ng ↗github.com · Source ↗
- rbac.dev ↗github.com · Source ↗
Dominik Tornow is co-founder and chief executive of Resonate HQ and author of Think Distributed Systems. He develops programming models for software that must keep working through crashes, delayed messages, and incomplete information. At Resonate, that work has led to a specific proposition for coding agents: a small distributed-systems protocol can become the reusable product, with implementations generated for infrastructure a team already operates.
On this page
Programming across interruptions
Dominik studied software systems engineering at Germany’s Hasso Plattner Institute and worked at SAP, Cisco, and Temporal, including principal-engineering roles at Cisco and Temporal. At SAP, his work included development tools, engineering processes, and collaboration; at Cisco, his interests included Kubernetes networking and service meshes. His book examines failures, transactions, replication, and consensus—the mechanisms through which components with incomplete local knowledge produce coordinated behavior.
In June 2023, Dominik founded Resonate with longtime colleague David Farr. The company announced $3 million in seed funding in June 2025. Its central programming model, distributed async/await, extends familiar asynchronous programming across machines and interruptions. An operation can wait and later resume, with the execution machinery preserving the progress needed to recover from failure. For an agent, that can mean continuing work after an external service responds or a person grants approval.
Dominik explores the model in his own minimal distributed async/await framework. His definition of durable execution separates interruption-tolerant computation from any particular framework. Resonate’s open-source projects include a durable-execution server, SDKs for TypeScript, Python, Rust, Go, and Java, and a Lean 4 protocol specification.
From generating code to designing systems
Dominik argues that coding agents could move infrastructure reuse upstream: teams would reuse a specification and derive implementations suited to their existing systems. He calls this the specification is the product. It is a proposed direction for infrastructure software, grounded in Resonate’s experiments with generating implementations for Postgres and NATS.
In The Prompt is the Platform, he describes an early attempt to generate a Rust server on Postgres directly from an abstract specification. The result passed basic tests but failed under concurrency, process crashes, and network failures. The team introduced a concrete specification covering schemas, indexes, queries, and transaction boundaries. That enabled the agent to implement the system, but people still supplied the consequential design decisions.
For Resonate’s work with Synadia on NATS, the team changed the process again. The agent first built an implementation inside a deterministic simulator, where it could investigate algorithms before deriving a concrete specification and production code. This gave the agent a role in design as well as implementation. Dominik credits three years of collective simplification with making the approach feasible: Resonate’s protocol centers on durable promises and tasks, limiting the concepts whose concurrent behavior must be understood.
Two distinctions explain how that approach works:
- Reproduce the failure. A simulated versioned key-value store can return an older value, then reject a write because the version has already changed. Such a stale read is permitted by the target’s consistency model; the algorithm must handle it. Deterministic simulation lets engineers and agents replay the same sequence and investigate the decision that caused a failure.
- Expose more to the debugger than to the algorithm. The simulator can record both the stale value the algorithm received and the newer value it missed. Production code cannot rely on that hidden information. An agent debugging the algorithm can use it to understand why a decision was wrong, without building an assumption into the implementation that the real system cannot satisfy.
Durable execution on existing infrastructure
Dominik’s critique of custom queues favors durable execution that works with infrastructure teams already use. Postgres and NATS make the tradeoff concrete: relational schemas and transactions offer different building blocks from queues, versioned key-value storage, and scheduled messages. A reusable protocol must leave those implementation choices open while defining the behavior each implementation must preserve.
His Systems Engineering for Agentic Applications applies distributed-systems principles to autonomous software. His AI reminder assistant example brings the problem down to a small application: long-running work must be able to suspend and resume. The same concern connects his programming model to his agent-assisted design experiments—preserving application progress requires explicit guarantees, and implementing those guarantees requires feedback about failures beyond the happy path.
Read the topics behind these talks
1 conference talk
Loading more talks and highlights…
References
- ai.engineer/talks/the-prompt-is-the-platform ↗
- manning.com/authors/dominik-tornow ↗
- dtornow.com ↗
- dtornow.com/blog ↗
- github.com/dtornow/async-await-mechanics ↗
- github.com/dtornow ↗
- github.com/dtornow/fossasia-summit-2024 ↗
- github.com/dtornow/minimal-distributed-async-await ↗
- github.com/dtornow/ng ↗
- github.com/dtornow/rbac.dev ↗
