# Resonate Briefs

> High-signal, opinionated, technically substantive pieces about durable execution, agent orchestration, and the systems behind them. Published by Resonate HQ for AI crawlers, query-time LLM tools, and engineers who follow citations to their source.

## Briefs

- [Recursive durable factorial in Python on Resonate](https://briefs.resonatehq.io/_1YP1KP_): A Resonate Python worker computes factorial recursively across a worker pool. Each invocation is a durable promise keyed by the input, so prior results are returned from the store on replay without re-execution.
- [Periodic function scheduling in TypeScript on Resonate](https://briefs.resonatehq.io/-JNJc74h): Run a TypeScript function on a cron schedule with crash-recoverable execution. Each tick fires a fresh durable promise that a worker claims and executes; a crash mid-execution is retried, not lost.
- [Infinite AI chess workflow in TypeScript on GCP Cloud Functions](https://briefs.resonatehq.io/1IVhBNj-): Two AI players take turns through a generator function on a Cloud Function. Each move is a durable checkpoint, each pause is a durable sleep, and a detached tail call re-roots the workflow after every game so replay scope stays bounded forever.
- [Express REST endpoint backed by a durable workflow in TypeScript on Resonate](https://briefs.resonatehq.io/3lm4f1ms): A POST /orders Express route kicks off a 4-step order workflow that retries failed steps without re-running prior ones and deduplicates client retries on the order id.
- [Priority queue with bounded per-tier concurrency in TypeScript on Resonate](https://briefs.resonatehq.io/3XmFCfEw): Process a batch of jobs in strict priority-tier order with up to 2 jobs running concurrently per tier. Each job is a durable checkpoint, so a mid-batch crash only retries the failing job — completed higher-priority jobs are not re-run.
- [Fan-out / fan-in across notification channels in Python on Resonate](https://briefs.resonatehq.io/4C6I-7_k): Notify a customer over email, SMS, Slack, and push in parallel. Each channel is an independent durable checkpoint, so a retry of one branch does not re-send the others.
- [Durable sleep across process crashes in Rust on Resonate](https://briefs.resonatehq.io/4tn3eEia): Suspend a workflow for seconds, days, or years without holding a process open. The sleep is a server-backed timer promise; another worker resumes the workflow when the timer fires, even if the original worker is gone.
- [Per-message Kafka worker with crash recovery in Python](https://briefs.resonatehq.io/50-9cqVC): A Redpanda consumer kicks off one durable workflow per message and returns immediately. Each step is a checkpoint; a worker crash mid-deletion resumes from the last completed batch, and the record id deduplicates retries.
- [Durable onboarding workflow on Supabase Edge Functions in TypeScript](https://briefs.resonatehq.io/5IsiSHkS): A Supabase Database Webhook fires an Edge Function on user INSERT; Resonate makes the four-step onboarding workflow durable across function invocations, retries, and duplicate webhook deliveries.
- [Fan-out / fan-in across notification channels in TypeScript on Resonate](https://briefs.resonatehq.io/6FjF6y0z): Notify a customer over email, SMS, Slack, and push in parallel. Each channel is an independent durable checkpoint, so a retry of one branch does not re-send the others.
- [Async HTTP API with durable workers in TypeScript on Resonate](https://briefs.resonatehq.io/6p_I0T0Y): Accept an HTTP request, dispatch durable work to a separate worker process, and let the client poll for completion. The gateway holds no state; Resonate keeps the promise alive across worker crashes and restarts.
- [Load balancing across worker instances in Rust on Resonate](https://briefs.resonatehq.io/7iIp2EFF): Run multiple Rust workers in a named group and dispatch durable RPCs to any one of them. The Resonate Server handles service discovery, load balancing, and recovery; the worker code is one function and a group string.
- [AWS Lambda as a stateless trigger for durable Python workflows](https://briefs.resonatehq.io/8IBDheBK): AWS Lambda has a hard 15-minute execution ceiling. Split the work: Lambda accepts the request and dispatches a durable RPC, and a long-running Resonate worker runs the multi-step workflow with each step checkpointed.
- [Long-lived human-in-the-loop step in TypeScript on Resonate](https://briefs.resonatehq.io/9UkwVJEQ): Block a Resonate generator workflow on human approval for an indefinite duration. The workflow yields a latent durable promise; an Express gateway settles it from outside, and the suspension survives worker crashes.
- [Long-lived human-in-the-loop step in Python with an HTTP gateway](https://briefs.resonatehq.io/angRO0qX): Block a workflow on a human click without polling, schedulers, or queues. The workflow yields a durable promise that an HTTP gateway resolves from outside on a later request.
- [Recursive distributed calculator in Python on Resonate](https://briefs.resonatehq.io/ATnFxX6e): Parse an arithmetic expression into a tree, then recursively dispatch each sub-expression to a worker pool and the operator to a separate pool. Every sub-expression is its own durable promise, so partial results survive crashes and the recursion is plain Python.
- [Next.js Server Action backed by a durable workflow in TypeScript](https://briefs.resonatehq.io/bJTVx638): A Next.js Server Action kicks off a 4-step background workflow keyed by a report id; a separate API route resolves the same id to poll for completion. The workflow and the status route share one in-process Resonate registry.
- [Distributed mutex via generator sequencing in TypeScript on Resonate](https://briefs.resonatehq.io/bWLQfb3S): Serialize N workers around a shared resource without a lock workflow or signal channel. A generator that yields each worker in a for-loop IS the mutex; the SDK handles crash recovery and retry.
- [Saga workflow behind an HTTP API in TypeScript on Resonate](https://briefs.resonatehq.io/cDXrCjm7): Move funds between two accounts as a debit + credit saga, triggered by an Express POST and made durable by Resonate. Idempotency is enforced at the execution id and at the ledger row.
- [Recursive workflow with cached results in Rust on Resonate](https://briefs.resonatehq.io/CFbGqt0F): Compute factorial(n) by having one function call itself across a worker group. Each call pairs with a durable promise keyed by n, so previously computed results return without recomputing.
- [Multi-agent pipeline with durable handoffs in Python on Resonate](https://briefs.resonatehq.io/cZP82z5T): Coordinate researcher, writer, and reviewer agents in sequence. Each agent handoff is a durable checkpoint, so a failure mid-pipeline retries only the failed agent — completed agents are not re-run.
- [Exposing Resonate workflows as MCP tools in TypeScript](https://briefs.resonatehq.io/Db6qBnFW): Wrap a Resonate workflow behind a stdio MCP server so an AI client can call it as a tool. Each tool invocation runs as a durable execution with replay, retry on throw, and durable timers.
- [Multi-agent pipeline with durable handoffs in TypeScript on Resonate](https://briefs.resonatehq.io/dhqdzoPh): Sequence three LLM agents — researcher, writer, reviewer — through one generator workflow. Each `yield* ctx.run(...)` is a durable checkpoint, so a mid-pipeline failure retries only the failed agent.
- [Async RPC across services in Python on Resonate](https://briefs.resonatehq.io/EISJ8rhG): Cross-process function calls survive node crashes when the call graph is a durable promise. The example shows await-chain, detached-chain, and fan-out flows in Python using rpc, rfc, rfi, and detached.
- [Recursive deep-research agents across TypeScript, Python, Rust](https://briefs.resonatehq.io/elh8AwjA): A recursive LLM agent that decomposes a topic into subtopics and dispatches a fresh durable workflow per subtopic, with six sibling variants spanning plain Node, Cloudflare Workers, Google Cloud Functions, Supabase Edge Functions, Python, and Rust.
- [Long-lived human-in-the-loop step in Rust with an HTTP gateway](https://briefs.resonatehq.io/ELqEcPXY): Block a Resonate workflow on human approval for an indefinite duration. The workflow awaits a latent durable promise; an HTTP gateway resolves it from outside, and the suspension survives worker crashes.
- [Multi-step off-chain scoring with durable child promises in TypeScript](https://briefs.resonatehq.io/EpOwWA0K): A blockchain event triggers a multi-step off-chain workflow whose every step is a durable child promise. The orchestrator is a generator function; each child is registered separately on a named worker group.
- [Async HTTP API with durable workers in Rust on Resonate](https://briefs.resonatehq.io/eQCDmmTq): Accept an HTTP request, dispatch durable work to a separate worker process, and let the client poll for completion. The gateway holds no state; Resonate keeps the promise alive across worker crashes and restarts.
- [Durable webhook deduplication keyed by event_id in TypeScript](https://briefs.resonatehq.io/EqUWEtQD): 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.
- [Durable entity as a long-running workflow in TypeScript on Resonate](https://briefs.resonatehq.io/EyFlxCI5): Model a user session as a long-running generator: login, per-activity checkpoints, durable idle timeout, and cleanup. Crashes resume mid-lifecycle without re-recording earlier activities or restarting the timer.
- [Durable MCP tools that coordinate by promise id in Python](https://briefs.resonatehq.io/ff6Oi3yC): Three MCP tools — start_gathering, probe_status, await_result — coordinate on one Resonate durable promise keyed by job name; after a crash the worker reclaims the promise and re-runs the function from the top.
- [Async RPC across services in TypeScript on Resonate](https://briefs.resonatehq.io/fIdik3qx): Cross-process function calls survive node crashes when the call graph is a durable promise. The example shows await-chain, detached-chain, and fan-out flows using a single TypeScript SDK with three RFI shapes.
- [Hello World quickstart in TypeScript on Resonate](https://briefs.resonatehq.io/fozO91zh): The minimum durable program in the Resonate TypeScript SDK: one generator workflow, two async leaf functions, no server required. Each ctx.run call is a durable checkpoint that short-circuits on replay.
- [Durable multi-turn chatbot with checkpointed LLM calls in TypeScript](https://briefs.resonatehq.io/G2EZ5Z2P): A multi-turn chatbot must survive transient LLM failures mid-turn without re-prompting the user or paying twice for the same completion. On Resonate, each turn is a workflow keyed by session and turn number, and the Claude call inside it is a ctx.run checkpoint.
- [Write Last, Read First account creation in TypeScript with TigerBeetle](https://briefs.resonatehq.io/h_sxiQPI): Create an account in a System of Reference (SQLite) and a System of Record (TigerBeetle) without a distributed transaction. Each step is a Resonate durable checkpoint; replays after a crash skip completed steps and finish the write.
- [Long-running Hacker News research agent in TypeScript on Resonate](https://briefs.resonatehq.io/HiAebSFP): A continuous LLM-driven monitor that scans Hacker News, scores stories for relevance, and notifies on findings. Each step is a durable checkpoint and the deduplication set rebuilds itself from the promise store on restart.
- [Durable sleep across process crashes in TypeScript on Resonate](https://briefs.resonatehq.io/HIRHoYmX): Suspend a generator workflow for seconds, days, or years without holding a process open. The sleep is a server-backed timer promise; any worker in the group resumes the workflow when the timer fires.
- [Human-in-the-loop summarization agent in Python on Resonate](https://briefs.resonatehq.io/Hu3iGaDF): Scrape a URL, summarize it with a local LLM, then block on a durable promise until a human confirms or rejects. Rejection re-runs the summarize step; confirmation completes the workflow.
- [Lambda as a stateless trigger for a durable workflow in TypeScript](https://briefs.resonatehq.io/iBYk9x9i): AWS Lambda accepts a document-processing request and returns 202, then a Resonate durable workflow runs the multi-step pipeline on a separate worker that has no 15-minute ceiling.
- [Saga with compensating actions in TypeScript on Resonate](https://briefs.resonatehq.io/IhcLmmB3): Book a flight, hotel, and car rental as a single transaction. If the car rental fails, hotel and flight are cancelled in reverse order. Each step is a durable checkpoint, so a crash mid-compensation resumes where it left off.
- [Human-in-the-loop Kubernetes node drain in TypeScript on Resonate](https://briefs.resonatehq.io/iLbP3doX): Drain Kubernetes worker nodes durably: each node drain is a checkpoint, and when a Pod Disruption Budget blocks eviction the workflow blocks on a durable promise until an operator resolves it over HTTP.
- [Load balancing across a worker group in Python on Resonate](https://briefs.resonatehq.io/ItZvdlDN): Spread work across N identical Python workers and recover in-flight executions when one of them crashes, by tagging each worker with a group name and addressing the call to any member of that group.
- [Browser tab as a Resonate worker in TypeScript](https://briefs.resonatehq.io/JWrjBKZs): Host a Resonate worker inside a browser tab so durable invocations are claimed and executed by client-side code. The tab subscribes to the Resonate server over SSE, claims tasks for its worker group, and resumes work after a refresh because every step is a durable promise.
- [One-click buy with a durable cancellation window in TypeScript on Resonate](https://briefs.resonatehq.io/K-0rsUiD): Start a purchase, open a 5-second window in which the user can cancel, then confirm or cancel. The window is one `ctx.run` over a Promise that races a timer against an EventEmitter signal — checkpointed, so a crash mid-window resumes from where it left off.
- [Embedding Resonate inside Flask, FastAPI, and Django handlers in Python](https://briefs.resonatehq.io/k8PZxOb4): A request handler invokes a Resonate-registered function; the SDK executes it as a durable promise inside the same process and returns the result inline.
- [Saga with compensating action in Python on Resonate](https://briefs.resonatehq.io/kVj4ALhH): Move funds between two accounts with debit + credit + compensating reversal against a SQLite ledger. Each step is a durable checkpoint and replays are idempotent on a deterministic op_id.
- [Infinite monitoring workflow in TypeScript on Resonate](https://briefs.resonatehq.io/M28ujOi3): A health monitor that loops forever — check services, alert, sleep, repeat. The loop is a plain while; each iteration is a Resonate checkpoint, each pause is a durable sleep, and there is no history-size limit to reset by hand.
- [Multi-step food delivery saga in TypeScript on Resonate](https://briefs.resonatehq.io/mOnBrCu5): A six-step food delivery pipeline — order, prepare, assign driver, pickup, deliver, complete — where every step is a durable checkpoint and a transient mid-step failure retries in place without re-invoking earlier steps.
- [Token authentication and prefix authorization in TypeScript on Resonate](https://briefs.resonatehq.io/NoBYFSQj): Restrict which clients can talk to the Resonate server and which promise IDs each client can touch by passing a signed JWT and a prefix claim to the Resonate constructor.
- [Durable Hacker News research agent in Python on Resonate](https://briefs.resonatehq.io/OfURXm0J): Continuously scan Hacker News, score each story with an LLM, and notify on hits — without re-analyzing stories after a crash. Every step is a Resonate checkpoint and the dedup set rebuilds on replay, so no external database is needed.
- [Periodic function on a cron schedule in Rust on Resonate](https://briefs.resonatehq.io/OIDzB0xH): Run a Rust function on a cron expression where every tick is a durable promise on the server. If a worker crashes mid-tick, another worker in the group resumes the same execution — the tick is not lost.
- [Event sourcing with per-event durable checkpoints in TypeScript](https://briefs.resonatehq.io/Olz-YuwX): 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.
- [Hello World quickstart in Rust on Resonate](https://briefs.resonatehq.io/pxiLttld): 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.
- [Resilient website summarization agent in TypeScript on Resonate](https://briefs.resonatehq.io/Pz1A3njZ): 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.
- [Durable webhook deduplication keyed by event_id in Python](https://briefs.resonatehq.io/QdgjrL7X): 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.
- [Durable MCP tool handler in Rust on Resonate](https://briefs.resonatehq.io/qVUSHf6y): 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.
- [Durable countdowns across AWS, Cloudflare, GCP, Supabase, Kafka, browser, and Python](https://briefs.resonatehq.io/qYiMD3rq): 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.
- [Fan-out / fan-in with durable per-item recovery in Rust on Resonate](https://briefs.resonatehq.io/rYMgOHmZ): 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.
- [Parallel AI image generation with fan-out / fan-in in TypeScript on Resonate](https://briefs.resonatehq.io/sDamh-X2): 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.
- [Worker-group routing for an on-premise FaaS in Python on Resonate](https://briefs.resonatehq.io/siF8-c9J): 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.
- [Async MCP tool backed by a durable background job in Python](https://briefs.resonatehq.io/smVGxgFp): 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.
- [Durable order-lifecycle state machine in TypeScript on Resonate](https://briefs.resonatehq.io/t9BgqCsq): 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.
- [Recursive factorial as a durable workflow in TypeScript](https://briefs.resonatehq.io/TCsuorqo): 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.
- [Payload encryption at the promise store boundary in TypeScript](https://briefs.resonatehq.io/teUgAi5u): 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.
- [Async HTTP API with durable workers in Python on Resonate](https://briefs.resonatehq.io/TEyUO5-o): 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.
- [Durable rate-limited batch processing in TypeScript on Resonate](https://briefs.resonatehq.io/TKWqCsJ2): 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.
- [Coordinating a Databricks job from a backend in Python with Resonate](https://briefs.resonatehq.io/u_KFfR3z): Trigger a Databricks job from a FastAPI service and resume a workflow when the job calls back, without splitting business logic across event handlers. The orchestrator yields a durable promise that the notebook resolves over HTTP.
- [Durable sleep across process crashes in Python on Resonate](https://briefs.resonatehq.io/u54Ui0Dl): Suspend a workflow for seconds, days, or years without holding a Python process open. The sleep is a server-backed timer promise; another worker resumes the workflow when the timer fires, even if the original worker is gone.
- [Schedule-and-act reminder agent in Python on Resonate](https://briefs.resonatehq.io/ucLWaG3k): An LLM-driven reminder assistant that parses a natural-language request, picks a target timestamp, and sleeps until then before sending the reminder. The sleep is a durable timer, so no cron, queue, or database is needed.
- [Load balancing across worker instances in TypeScript on Resonate](https://briefs.resonatehq.io/VI2d-6gD): Run multiple TypeScript workers in a named group and dispatch durable RFIs to any one of them. The Resonate Server handles service discovery, load balancing, and dispatch recovery; the worker code is one function and a group string.
- [Hello World quickstart in Python on Resonate](https://briefs.resonatehq.io/wOo1-t_S): The minimum Resonate Python workflow: one generator function calls two ordinary functions through ctx.run, and the SDK turns each call into a durable checkpoint with zero server setup.
- [Per-message Kafka worker with crash recovery in Rust](https://briefs.resonatehq.io/WusNAGC3): A Redpanda consumer dispatches one durable Resonate workflow per message and immediately moves on. Each ctx.run is a checkpoint; a crash mid-deletion resumes from the last completed batch, and the record id deduplicates retries.
- [Per-message Kafka worker with crash recovery in TypeScript](https://briefs.resonatehq.io/Xsv0z6Hm): A Kafka consumer kicks off one durable workflow per message and returns immediately. Each step is a checkpoint; a worker crash mid-deletion resumes from the last completed batch, and the record id deduplicates retries.
- [Durable batch processor with checkpoint resume in TypeScript on Resonate](https://briefs.resonatehq.io/YT6LPIm_): Process a large record set in fixed-size batches and resume from the last completed batch after a crash. Each batch is a durable checkpoint; completed batches return from cache on replay without re-running.
- [Durable LLM tool-call loop for a travel assistant in Python on Resonate](https://briefs.resonatehq.io/yuOyIYh3): An LLM agent that searches the web, scrapes pages, and converses with a user across many turns must not lose context to a crash. Each LLM call, tool call, and user input becomes a durable checkpoint via `ctx.lfc`.
- [Recursive social-graph scraper in TypeScript on Resonate](https://briefs.resonatehq.io/Zwqgm_L-): Walk a Bluesky follower graph to bounded depth by spawning a detached durable workflow per follower. Each step is a checkpoint; the recursion survives worker restarts.
- [What resonate-bash is good at](https://briefs.resonatehq.io/Yk2qN8pD): Resonate's `resonate-bash` MCP tool runs shell commands as durable, asynchronous tasks. Good at: long polling loops, operations that outlive the session, named queryable state, and fire-and-watch coordination with external systems.

## Optional

- [RSS feed](https://briefs.resonatehq.io/feed.xml)
- [JSON Feed](https://briefs.resonatehq.io/feed.json)
- [Sitemap](https://briefs.resonatehq.io/sitemap.xml)