Durable Execution for Python & TypeScript

Build with vendor freedom.confidence.Resonate.

Develop reliable and scalable long-running workflows.agentic systems.background jobs.

But, without stressing over idempotency guarantees.function retries.crash recovery.

By developers, for developers.

Leave retries, crash recovery, idempotency guarantees, service discovery, load balancing, suspension, etc.. to Resonate .

Focus on your product.

Resonate APIs are the quality-of-life improvement developers have been waiting for.

Start building Talk to an engineer Subscribe

Why Resonate?

Evaluating durable execution options? Here's what makes Resonate different from other workflow engines.

Simple operations

Single binary, zero ops burden

Resonate Server is one binary that runs on Postgres. No clusters to manage, no complex deployments. Start with SQLite locally, scale to Postgres in production.

Familiar patterns

Async/await you already know

No new DSLs or workflow definitions. Write normal Python or TypeScript with async/await. Your existing mental model works—we just make it durable.

Battle-tested correctness

Formally modeled, deterministically tested

The Resonate protocol is modeled in Quint and tested with deterministic simulation. We find bugs before they reach production.

Truly open

Open source, no vendor lock-in

Apache 2.0 licensed. Self-host for free, forever. No per-execution pricing, no surprise bills, no platform dependency.

Quick comparison

Feature	Resonate	Traditional workflow engines
Deployment complexity	Single binary + Postgres	Multi-service cluster
Programming model	Native async/await	Custom DSL or decorators
Learning curve	Hours (if you know async)	Days to weeks
Self-hosted cost	Free, Apache 2.0	Free tier limits or paid
Local development	Same code, SQLite	Docker compose or cloud

Comparing to similar tools. Read the coming from guides →

Try it yourself Ask us anything on Discord

Complex problems. Simple code.

Async/await that spans services, agents, and human tasks.

Durable execution with automatic retries and crash recovery.

Available in Python and TypeScript — explore examples below.

Open source, open standards

Implements the open Distributed Async Await spec and the Async RPC protocol so discovery, load balancing, and recovery are transparent.

Get started with Resonate

Talk to an engineer

See it in action

Multi-step workflows

Write sequential code that survives crashes. Each step is checkpointed, so if your process fails, it resumes exactly where it left off.

Project files

src/workflow.py

from resonate import Resonate, Context

resonate = Resonate()

@resonate.register
def process_order(ctx: Context, order_id: str):
    # Each step is checkpointed - won't re-run on recovery
    order = yield ctx.run(fetch_order, order_id)
    payment = yield ctx.run(charge_card, order)
    shipment = yield ctx.run(create_shipment, order)
    yield ctx.run(send_confirmation, order["email"])
    return {"payment": payment, "shipment": shipment}

def fetch_order(ctx: Context, order_id: str):
    return {"id": order_id, "total": 99.99, "email": "[email protected]"}

def charge_card(ctx: Context, order: dict):
    return {"transaction_id": "txn_123", "amount": order["total"]}

def create_shipment(ctx: Context, order: dict):
    return {"tracking": "1Z999AA1", "carrier": "UPS"}

def send_confirmation(ctx: Context, email: str):
    print(f"Confirmation sent to {email}")

# Start a workflow
result = resonate.run("order-123", process_order, "123")
print(result)

What developers are saying

Real feedback from engineers in the community

This was my first time with a concrete, real-world use case for Resonate. After reaching out, Dominik and the team immediately took the time to jump on a call to walk through the requirements. I'm genuinely impressed by both the quality of thinking and the speed of execution. 'Going above and beyond' doesn't do it justice.

Yassin

Building distributed scraping infrastructure

I've been reading and playing with durable execution and found Resonate's approach to be awesome. Love the simplicity of the mental model and the DX!

Muniter

AI agents and data workflows

At my current job I've implemented many pipelines to generate vectors, wait for model execution, etc. and we use NATS with Jetstream for the async tasks. It adds a lot of complexity and overhead for such simple tasks. I think Resonate could be a great alternative. I'm reading the docs and this is incredibly great.

chrlie__

ML pipeline orchestration

The documentation is just excellent overall. I haven't looked at this for a while and I see it was updated—the 'Why Resonate' page really nails the systems engineering perspective.

Brad

Building workflow systems

Join the conversation on Discord

The path to reliable and scalable applications.

Whether it's a greenfield project, an existing codebase, or just an exploration — Using Resonate is delightful every step of the way.

built for builders

Under 5 min quickstart

Develop zero-dependency local workers

Spin up your first worker with zero extra services (No Resonate Server required). Keep local development dependency-free while you explore the APIs.

POC with a Resonate Dev Server

Use a local Resonate Server to enable reliability and scalability features.

Eable Durable workers

Enable your workers to survive restarts and crashes simply by connecting to the server.

Make Async RPCs

Call functions in other services as easily as local functions, synchronously or asynchronously.

Pluggable transports

BYO transport

Use Resonate's defaults or swap in your own message transport layer, such as Kafka, RabbitMQ, or AWS SQS.

Long-running on FaaS

Go serverless

Deploy your Resonate workers in serverless environments like AWS Lambda or Google Cloud Functions for automatic scaling and reduced operational overhead.

Real-world needs

Harden for production

Make use of out-of-the-box observability, privacy, and security tools and features for production-level deployments.

Fully decentralized

Scale limitlessly

Deploy as many Resonate Servers as your application needs. Both workers and servers can be added or removed dynamically to match demand.

Join the community.

Connect with the engineers building resilient systems today. Share feedback, see what's shipping next, and learn how teams are scaling with Resonate in production.