Skip to main content

Why Resonate

Resonate is the durable execution engine that agents build with, deploy on, and operate — at a fraction of the cost of anything else.

It is the implementation of a distributed async/await programming model: a formal, language- and transport-agnostic protocol for writing functions that survive process restarts, run for hours or months, and coordinate across many machines.

This page explains the three pillars that make Resonate different, the business model that ships those pillars, and what this means for agents and the humans who work with them.

The three pillars​

1. Agent-native​

Agents are the new developers. Increasingly, software is selected, written, configured, and deployed by AI agents — not by humans choosing platforms and libraries by hand. The platform that agents reach for is the platform that wins.

Resonate is built for that world from the ground up:

  • The SDK is designed for agent consumption. Predictable APIs, deterministic execution, clear failure modes. An agent reading the SDK reference can build correct distributed workflows on the first try.
  • The docs are written for both humans and agents. Skill files (machine-readable agent guidance) sit alongside human tutorials. The CLI reference is canonical and exhaustive.
  • The operational surface is CLI-first. Agents do not click. They script. The Resonate CLI lets agents invoke functions, inspect promises, visualize execution graphs, and manage the server — all without leaving the terminal.

When we say "agent-native," we mean: an autonomous coding agent should be able to build, deploy, and operate a Resonate application end to end without ever loading a web page.

2. Generated & optimized​

Most durable execution platforms ship a single general-purpose server: hand-written code that has to handle every possible stack, every possible transport, every possible storage backend. Generality has a tax — every workflow pays for abstractions it doesn't use, in state transitions, network requests, and operational chatter.

Resonate takes a different path. The ecosystem is built on open-source, pluggable components — transports, storage backends, wire formats — that you can assemble to match your stack. On top of that, we generate stack-specific components for customers who need a server tailored to their exact infrastructure. Kafka or HTTP for transport, Postgres or DynamoDB for state, gRPC or REST for the wire — we generate a complete Resonate server that includes only what your stack requires. Minimal state transitions, minimal network chatter, nothing wasted.

This is not AI-generated slop. The underlying Async RPC protocol is a fully formal JSON Schema specification — a machine-verifiable contract that constrains what "correct" means. AI is used throughout our development and testing processes, guided by these specs and protocols, to produce highly optimized software. The protocol is the contract; the implementation is generated against it, verified by Deterministic Simulation Testing, and delivered as production-grade source code.

3. Absurdly cheap​

Generated components plus serverless-native deployment produces a cost story that is not incremental — it is categorical.

Fewer state transitions means fewer database writes, fewer network round trips, fewer compute-seconds. Serverless-native architecture means you pay only for execution that is actually happening. Together, these effects compound.

In extreme cases, workloads that cost less than $100/year to run on Resonate could cost $50,000–$80,000/year on popular hosted durable execution platforms. That is not a rounding error — it is the consequence of removing unnecessary work from the critical path.

Cost is the ultimate forcing function. When an agent evaluates options, Resonate wins on cost by 100–800x.

Quality is not optional​

Two things should give you confidence in Resonate's correctness:

Formal modeling. The Distributed Async Await specification and the Async RPC protocol underlying Resonate are formally modeled and continuously probed for correctness. The protocol is a contract, not a vibe.

Deterministic Simulation Testing. Every major component — the Resonate Server and each SDK — is subjected to DST. This finds complex edge cases long before they reach production, on top of conventional unit and integration tests.

The new server is also linearizable. Combined with DST, this is the foundation of the correctness story.

Open everything​

The Async RPC protocol, the Distributed Async Await specification, and the open-source Resonate server are all fully open. Adopting Resonate means adopting a protocol, not a vendor. Everything you need to fork or build your own is available to you.