Page 5 of 6
How a generator with one ctx.run per event becomes a crash-resumable event sourcing pipeline without an external event store.
Reduce a stream of domain events into a state projection where each event is one durable checkpoint. Crash at event 5, resume at event 5; events 0-4 return from the durable promise store without re-applying.
The smallest unit of a Resonate Rust program — a workflow, a leaf function, and a worker — annotated for retrieval.
The minimum durable program in the Resonate Rust SDK: one workflow function, one leaf function, one worker process. Crash the worker mid-run and the execution resumes from the last checkpoint.
How a download/summarize/approve agent reads as straight-line generator code when scrape, LLM, notification, and human gate are all Resonate primitives.
Scrape a page, summarize it with an LLM, gate the result on human approval, and regenerate on rejection — as one generator workflow. Each step is a durable checkpoint and the approval pause is a latent durable promise the gateway settles from outside.
How a Stripe-style payment webhook becomes exactly-once when the event_id is the durable promise id and each step is a checkpoint.
Process Stripe-style payment webhooks exactly once by using the event_id as the Resonate promise id. Retries from the provider reattach to the existing durable execution instead of triggering a second charge.
How an MCP tool call dispatches into a Resonate workflow that checkpoints each step and deduplicates by promise ID.
Expose a durable Resonate workflow as a Model Context Protocol tool over stdio. The MCP server stays stateless, the workflow checkpoints each step on a worker process, and concurrent calls for the same input deduplicate by promise ID.
How one durable-sleep workflow runs on Lambda, Workers, Cloud Functions, Edge Functions, Kafka, browsers, and Python without changing the function body.
A countdown loop that sleeps between steps and survives crashes, shown across 8 deployment shapes. The workflow body is one generator; only the platform adapter changes.
How `ctx.run(...).spawn()` turns parallel work items into individually durable promises that survive process crashes.
Run several work items in parallel and collect their results, while keeping per-item progress durable across crashes. Each spawned task is its own durable promise, so a restart only re-executes items that had not completed.
How fan-out / fan-in over an AI-provider call collapses to two for-loops when each branch is a Resonate durable promise.
Generate multiple style variations of an image prompt in parallel, with per-branch crash recovery. Each generator call is a durable checkpoint; a failed call retries independently while the others continue.
How RPC, RFI, and ctx.detached split a FaaS submission into one durable orchestration on a router process and a pool of replaceable executors in a named worker group.
Submit function executions to a named worker group via durable RPC, RFI, and detached invocations; the orchestration survives worker crashes because the durable promise lives on the Resonate server, not in the router process.
How an MCP server returns a promise id instead of blocking, and lets the agent ask back later — backed by a Resonate-registered function and a durable sleep.
Expose a long-running job to an LLM as an MCP tool that returns a promise id immediately, then let the agent poll for completion against a durable promise on the Resonate server.
How a six-state order workflow collapses to straight-line generator code when each ctx.run call is a durable checkpoint.
An order moves through created, confirmed, shipped, delivered (or cancelled, refunded), and must resume cleanly mid-transition after a crash. With Resonate the generator's execution position IS the state — each transition is a ctx.run checkpoint, no K/V store required.
How recursion stays straight-line code when every invocation is its own durable promise.
A function that calls itself across worker processes, with each invocation backed by a durable promise so crashes resume from the last completed sub-call and repeat top-level calls return the stored result.
How a ~50-line AES-256-GCM Encryptor keeps PII out of the promise store without touching workflow logic.
Encrypt every value Resonate stores — function arguments, return values, intermediate state — by implementing a two-method Encryptor interface. Workflow code is unchanged; the codec calls encrypt() on the way in and decrypt() on the way out.
How a FastAPI gateway dispatches durable work to a worker group and lets clients poll a non-blocking status endpoint.
Accept an HTTP request, dispatch durable work to a separate worker process, and let the client poll for completion. The FastAPI gateway holds no state; Resonate keeps the promise alive across worker crashes and restarts.
How a for-loop with ctx.sleep between calls becomes a crash-safe per-workflow rate limiter with no external token bucket.
Send N API calls at a fixed rate using ctx.sleep between calls. The sleep is a durable checkpoint, so a crash mid-batch resumes at the next request without duplicating earlier ones and without bursting after restart.
We value your privacy
We use strictly necessary cookies to run this site. With your consent we also use Google Analytics to understand traffic. We do not load analytics until you choose to allow it. Privacy Policy.