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.
Temporal's sleep-for-days races a 30-day timer against a signal channel via NewSelector. Resonate's equivalent is ctx.Sleep(d) + f.Await(nil) — Selector gone, durability kept.
Port Temporal's sleep-for-days sample to Resonate. The timer leg of the Selector loop maps to ctx.Sleep(d) + f.Await(nil); crash recovery resumes on the remaining time, not from zero.
The two-loop discipline — dispatch all before awaiting any — is identical in both systems. `workflow.ExecuteActivity` / `future.Get` simply becomes `ctx.RPC` / `f.Await`.
Port Temporal's splitmerge-future Go sample to Resonate. The two-loop idiom is identical — dispatch all, then await all — but `ctx.RPC` replaces `workflow.ExecuteActivity` and `f.Await` replaces `future.Get`.
Temporal's child-workflow mechanism collapses into one registered function that calls itself by name via ctx.RPC. No separate child type, no ContinueAsNew, no per-child options.
Port Temporal's child-workflow pattern to Resonate. A function calls itself via ctx.RPC — no child-workflow type, no WithChildOptions, no ContinueAsNew to bound history.
Temporal's helloworld maps to a single Go function — no workflow/activity types, no task queue, no activity options. Just `resonate.Register` and a promise ID.
Port Temporal's helloworld Go sample to Resonate. The workflow/activity split, the task queue, and activity options collapse into one registered function invoked by a durable promise ID.
Temporal registers compensation eagerly with defer closures that unwind LIFO. Resonate runs it inline in the error branch — same reverse-order rollback, different shape.
Maps Temporal's saga sample to example-money-transfer-go: defer-LIFO compensation vs. inline guarded undo — same reverse-order rollback, different code shape.
Temporal's await-signals needs a signal channel, a listener goroutine, a flag, and workflow.Await. Resonate collapses all four into one ctx.Promise().
Port Temporal's await-signals pattern to Resonate. One latent ctx.Promise() replaces a signal channel, a listener goroutine, a flag variable, and workflow.Await — the promise record itself is the pending state.
The durable-loop-of-ticks pattern — ctx.RPC then ctx.Sleep each iteration — replaces workflow.ExecuteActivity + workflow.NewTimer + NewSelector with two two-liners per tick.
A durable loop of ctx.RPC + ctx.Sleep ticks that resumes at the next pending tick after a crash; maps structurally to Temporal's sleep-for-days, timer, and cron samples.
Checkpointed steps + an operator approval gate: a production Go orchestrator that maps two Temporal patterns to two Resonate primitives.
A Kubernetes node-drain orchestrator composing checkpointed steps (ctx.Run) and an operator approval gate (ctx.Promise) — mapping Temporal's saga and await-signals patterns side by side.
ctx.RPC + Await, ctx.Detached, and the two-loop fan-out — mapped from Temporal's child-workflow, ABANDON policy, and splitmerge-future.
Three RPC dispatch shapes — await-chain, detached, and fan-out — mapped from Temporal child-workflow variants to Resonate's ctx.RPC and ctx.Detached.
How a self-calling function stays durable and content-addressed when every invocation is its own durable promise.
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.
A worked example of `resonate.schedule()` — what the server persists, what the worker claims, and what the function author writes.
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.
How an AI-vs-AI chess match becomes a generator on a serverless function — durable, bounded in replay, recursive across games via ctx.detached.
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.
How an Express route handler triggers a durable generator workflow with no separate worker process, no event schema, and no mount point.
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.
A nested loop over priority tiers becomes the scheduler when every yield* is a durable Resonate checkpoint.
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.
How the fan-out / fan-in pattern collapses to four `yield ctx.rfi(...)` calls plus four `yield <handle>` fan-in points when every branch is a durable promise.
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.
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.