resonatehq

@resonatehq source repo

60 skills
0 followers
6 hours ago last updated

▌
Resonate CLI · resonatehq
resonate-cli

0
installs
▌
Resonate Bash · resonatehq
Run shell scripts as durable, asynchronous tasks via Resonate's `resonate-bash` MCP tool. Reach for this when waiting on something that takes minutes-to-hours (CI runs, deploys, DNS / SSL propagation, image-generation jobs), when work must survive a session close or host crash, or when you want a named, queryable promise ID a later session can look up. Covers what `resonate-bash` is good at, how to install the local Resonate server + Claude Code MCP wiring, the tool's parameter surface, target addresses (local / Docker / Tensorlake), failure semantics, and idempotency rules.

0
installs
▌
Durable Execution · resonatehq bundle
Conceptual introduction to durable execution — what it is, why you'd want it, and the tradeoffs between rolling your own (just your DB) versus using a framework like Resonate. Read this BEFORE picking an implementation. For the Resonate SDK's concrete Context API (ctx.run, ctx.sleep, ctx.promise, structured concurrency), use the per-SDK skill for your language — resonate-basic-durable-world-usage-{typescript,python,rust,go}.

0
installs
▌
Resonate Defaults · resonatehq
Look up default values across the Resonate server and SDKs (TypeScript, Python, Rust, Go). Use when answering "what is the default for X?" — retry policies, ctx.run timeouts, Options fields, init parameters, server flags, or RESONATE_* environment variables. Directs to the canonical defaults reference and the per-SDK source files; do not deflect to "check the SDK source" — read the source listed here.

0
installs
▌
Resonate Philosophy · resonatehq
The foundational mindset for building with Resonate. Read this FIRST before any other Resonate skill. Teaches you to write simple, sequential code and avoid over-engineering.

0
installs
▌
Resonate Server Nats · resonatehq
Run the Resonate protocol on NATS JetStream using resonate-on-nats — a separate Go server where NATS is both storage and transport, with no HTTP interface at all. Covers dev vs serve, partitioning across instances, wiring workers with the NatsNetwork client in the TypeScript and Python SDKs, the subject layout, the lowercase group/pid trap, the BUSL-1.1 constraint, and the current gaps. Use when a user already runs NATS and asks to run Resonate on it.

0
installs
▌
Resonate Saga Pattern Go · resonatehq
Implement saga patterns for distributed transactions in Go with Resonate — forward steps tracked in a slice with compensating actions that unwind in reverse on failure, using explicit (T, error) returns and a type Step string + switch for compensation dispatch. Use when coordinating multi-step Go workflows that need consistency across failures without a distributed transaction. Verified against the resonate-sdk-go 0.1.0 tag.

0
installs
▌
Resonate Server Postgres · resonatehq
Run the Resonate protocol inside Postgres itself using resonate-pg — one SQL file of stored procedures, with no server process at all. Covers installing the schema, the pg_cron timer dependency and its silent-failure mode, reaching the protocol through resonate_rpc, starting workflows with resonate.invoke, the resonate_worker grant surface, garbage collection and id idempotency, the TypeScript/Deno-only client constraint, and the open correctness gaps. Use when a user already runs Postgres and wants durable execution without deploying anything beside it.

0
installs
▌
Resonate Server Scylladb · resonatehq
Run the Resonate protocol on ScyllaDB using resonate-on-scylladb — a separate Go server, not a storage backend of the core server. Covers local and existing-cluster setup, the SCYLLADB_/SERVER_/TIMEOUTS_/WORKER_ environment model (which is NOT the core server's RESONATE_ model), the six-table schema, the BUSL-1.1 licensing constraint, and the current gaps. Use when a user already runs ScyllaDB or another wide-column store and asks to run Resonate on it.

0
installs
▌
Resonate Migrate From Dbos · resonatehq
Port a DBOS application to Resonate, pattern by pattern. Use when migrating DBOS workflows/steps, durable queues, send/recv and setEvent/getEvent communication, durable sleep, scheduled (cron) workflows, child workflows, or saga-style compensation to the Resonate SDK. Maps canonical dbos-inc demo and SDK examples to their Resonate equivalents across TypeScript, Python, Rust, and Go, with per-SDK API notes and honest coverage gaps. Foundational skill — delegates to the per-SDK pattern skills for idiomatic target code.

0
installs
▌
Resonate Saga Pattern Java · resonatehq
Implement saga patterns for distributed transactions in Java with Resonate — forward steps wrapped in a try/catch, each tracked in a List, with compensating actions that unwind in reverse on failure. Uses an enum + switch for compensation dispatch and the retry policy (Retry.Never / bounded Exponential) to control which steps retry, since the Java SDK has no non-retryable error wrapper. Use when coordinating multi-step Java workflows that need consistency across failures without a distributed transaction. Verified against develop/java.mdx (docs PR

0
installs
▌
Resonate Saga Pattern Rust · resonatehq
Implement saga patterns for distributed transactions in Rust with Resonate — forward steps with compensating actions that unwind on failure using Result<T> and match-based compensation dispatch. Use when coordinating multi-step Rust workflows that need consistency across failures. SDK in active development (0.6.0 on crates.io); API surface may change between releases.

0
installs
▌
Resonate Server Deployment · resonatehq
Deploy and configure the Resonate server on Linux systems with systemd. Covers installation, public URL configuration, JWT authentication, and troubleshooting.

0
installs
▌
Resonate Basic Debugging Go · resonatehq
Debug and troubleshoot Resonate applications using the Go SDK. Use when investigating stuck or never-resuming workflows, duplicated side effects after replay, promise decode errors, latent-promise settlement encoding traps on the low-level Sender().PromiseSettle path, localnet heartbeat failures, or version caveats of the Go SDK. Verified against the resonate-sdk-go 0.1.0 tag.

0
installs
▌
Resonate Saga Pattern Python · resonatehq
Implement saga patterns for distributed transactions in Python with Resonate — forward steps with compensating actions that unwind on failure. Use when coordinating multi-step Python processes that need consistency across failures without distributed locks or two-phase commits.

0
installs
▌
Resonate Basic Debugging Java · resonatehq
Debug and troubleshoot Resonate applications using the Java SDK. Use when investigating stuck or never-resuming workflows, duplicated side effects after replay, untyped-handle decode surprises (Integer vs Long), CLI positional-argument arity mismatches, the detached by-name-only constraint, Java 21 / virtual-thread requirements, rejected-promise error handling, or r.stop() silently killing a live worker. Verified against the resonatehq-examples/*-java repos and develop/java.mdx (docs PR

0
installs
▌
Resonate Basic Debugging Rust · resonatehq
Debug and troubleshoot Resonate applications using the Rust SDK. Use when investigating registration errors, serde serialization failures, tokio runtime mismatches, install issues, or SDK-version-specific caveats of the early-development Rust SDK.

0
installs
▌
Resonate Migrate From Temporal · resonatehq
Port a Temporal application to Resonate, pattern by pattern. Use when migrating Temporal Workflows/Activities, Signals, timers, sagas, continue-as-new loops, fan-out/fan-in, child workflows, distributed mutex, or encryption to the Resonate SDK. Maps canonical temporalio/samples-* examples to their Resonate equivalents across TypeScript, Python, Rust, and Go, with per-SDK API notes and honest coverage gaps. Foundational skill — delegates to the per-SDK pattern skills for idiomatic target code.

0
installs
▌
Resonate Basic Debugging Python · resonatehq
Debug and troubleshoot Resonate applications using the Python SDK v0.7.0 and Resonate Server v0.9.x. Use when investigating stuck workflows, non-deterministic replays, registration errors, async/await mistakes, unexpected retries, or server connectivity issues.

0
installs
▌
Resonate Saga Pattern Typescript · resonatehq
Implement saga patterns for distributed transactions with compensation logic. Use when coordinating multi-step processes that need to maintain consistency across failures by unwinding completed steps.

0
installs
▌
Resonate Basic Debugging Typescript · resonatehq
Debug and troubleshoot Resonate applications and deployments, especially TypeScript SDK and Resonate Server issues. Use when investigating failures, stuck workflows, error codes, or unexpected replays.

0
installs
▌
Resonate GCP Deployments Typescript · resonatehq
Deploy Resonate TypeScript workers to Google Cloud Functions (Gen 2) using the GCP shim and connect them to a Resonate Server.

0
installs
▌
Resonate HTTP Service Design Python · resonatehq
Design HTTP services in Python that use Resonate durable functions behind FastAPI / Flask / Django route handlers — routing patterns, workflow boundaries, RPC to specialized worker groups, webhook-driven promise resolution. Use when building or refactoring Python HTTP APIs that trigger durable workflows.

0
installs
▌
Resonate Server Deployment Cloud Run · resonatehq
Deploy the Resonate server to Google Cloud Run with Cloud SQL Postgres storage. Covers Dockerfile reuse, the Cloud SQL Auth Proxy Unix socket, mandatory server URL, JWT authentication via Secret Manager, and configuration through `RESONATE_` environment variables.

0
installs
▌
Resonate Basic Durable World Usage Go · resonatehq
Core patterns for writing Resonate durable functions in Go — function kinds (registered vs leaf), Context APIs (ctx.Run, ctx.RPC, ctx.Sleep, ctx.Promise, ctx.Detached, Future.Await), option structs, context accessors, retries (bounded 3-attempt default), fan-out/fan-in, and the replay model. Verified against the resonate-sdk-go 0.1.0 tag.

0
installs
▌
Resonate Human In The Loop Pattern Go · resonatehq
Implement human-in-the-loop workflows in Go with the Resonate SDK — durable functions that park on ctx.Promise() until an external actor settles the latent promise, preferably via the Promises().Resolve/Reject/Cancel sub-client (shipped in 0.1.0); the CLI, the server HTTP API, and the low-level Sender().PromiseSettle remain as alternates for cross-process or non-Go settlement.

0
installs
▌
Resonate Recursive Fan Out Pattern Go · resonatehq
Implement recursive fan-out / parallel workflow execution in Go with Resonate — dispatch all children via ctx.RPC or ctx.Run, collect futures in a slice, then await each. Use when processing batches, trees, or graphs where each child is independently durable and optionally recurses. Verified against the resonate-sdk-go 0.1.0 tag.

0
installs
▌
Resonate State Bus Pattern Typescript · resonatehq
Stream durable workflow state to browsers (or any live subscriber) via an external realtime bus. Use this pattern when the worker is short-lived or scales to zero — keeping the worker stateless, making progress observable, and decoupling clients from the workflow's lifecycle.

0
installs
▌
Resonate Advanced Reasoning · resonatehq
Advanced reasoning bridge between the Resonate specification (resonatehq/resonate-specification) and the Resonate TypeScript SDK. Use when mapping spec concepts (processes, executions, promises, coordination, recovery) to concrete SDK patterns and when validating correctness, durability, and failure semantics.

0
installs
▌
Resonate Async Await Engine Typescript · resonatehq
The Resonate TypeScript SDK's async/await execution engine — import from @resonatehq/sdk/async, register async functions, eager ctx.run fan-out with Promise.all, Never-default retries and Exponential opt-in, and when to choose the async engine vs the generator engine. Introduced in v0.11.0. Use when writing new TypeScript workflows with async/await instead of function*/yield*.

0
installs
▌
Resonate Basic Durable World Usage Java · resonatehq
Use when writing the body of a Java durable function — any method registered with r.register or passed as a method reference to ctx.run. Core patterns for the Context API surface — the Context first-parameter signature, Context APIs (ctx.run, ctx.rpc, ctx.sleep, ctx.promise, ctx.detached, ResonateFuture.await), per-call options via ctx.options(new Opts()), context accessors (ctx.info), type-keyed dependency injection (ctx.getDependency), retry policies, dispatch-then-await fan-out, and the replay model. For multi-stage sleep timers, countdowns, and the cron Schedule API see resonate-durable-sleep-scheduled-work-java. Requires Java 21+ (virtual threads). Verified against the resonatehq-examples/*-java repos and develop/java.mdx (docs PR

0
installs
▌
Resonate Basic Durable World Usage Rust · resonatehq
Core patterns for writing Resonate durable functions in Rust using the

0
installs
▌
Resonate Basic Ephemeral World Usage Go · resonatehq
Core patterns for using the Resonate Go SDK's Client APIs from the ephemeral world — initializing a Resonate instance, registering durable functions with the package-level generic resonate.Register, invoking them top-level via RegisteredFunc.Run, dispatching remotely with Resonate.RPC, reconnecting to an existing execution with Resonate.Get, reading typed and untyped handle results, RunOptions, Stop semantics, and the direct Promises() / Schedules() sub-clients. Verified against the resonate-sdk-go 0.1.0 tag.

0
installs
▌
Resonate HTTP Service Design Typescript · resonatehq
Design HTTP services that use Resonate durable functions behind route handlers, including routing patterns, workflow boundaries, and RPC calls to other service workers (e.g., database service). Use when building or refactoring HTTP APIs that trigger durable workflows in TypeScript.

0
installs
▌
Resonate Human In The Loop Pattern Java · resonatehq
Implement human-in-the-loop workflows in Java with the Resonate SDK — durable functions that park on ctx.promise() until an external actor settles the latent promise. The Java SDK ships an r.promises sub-client, so external resolution is a clean r.promises.resolve(id, new Value(...)) call (or the CLI / server HTTP API) with no manual base64 encoding — the Go SDK's 0.1.0 tag now has the same Promises() sub-client, with manual base64 encoding only on its low-level Sender().PromiseSettle fallback. Use for approval gates, webhook callbacks, and operator unblock steps. Verified against develop/java.mdx (docs PR

0
installs
▌
Resonate Human In The Loop Pattern Rust · resonatehq
Resonate Human-in-the-Loop Pattern — Rust

0
installs
▌
Resonate Recursive Fan Out Pattern Java · resonatehq
Implement recursive fan-out / parallel workflow execution in Java with Resonate — dispatch all children via ctx.run or ctx.rpc collecting a List of ResonateFuture, then await each. Covers single-workflow fan-out, cross-worker recursion via ctx.rpc to a named worker group, and the worker/client split. Use when processing batches, trees, or graphs where each child is independently durable and optionally recurses. Verified against example-fan-out-fan-in-java and example-recursive-factorial-java and develop/java.mdx (docs PR

0
installs
▌
Resonate Recursive Fan Out Pattern Rust · resonatehq
Implement recursive fan-out in Rust with Resonate — spawn N sub-workflows via .spawn(), optionally recurse deeper, collect results with per-future .await. Use when processing a batch, tree, or crawl where each child is independently durable. SDK in active development; API surface may change between releases.

0
installs
▌
Resonate Durable Sleep Scheduled Work Go · resonatehq
Implement durable sleep and recurring-work patterns in Go with Resonate — ctx.Sleep(time.Duration) inside workflows for timers, countdowns, reminders, and long-horizon delays that survive process restarts; Resonate.Schedules() (shipped in 0.1.0) for direct cron-fired promises, plus in-workflow ctx.Sleep loops or external cron → RPC for recurring registered-function dispatch. Use when a workflow must wait for hours or days, or when a function should run on a fixed schedule. Verified against the resonate-sdk-go 0.1.0 tag.

0
installs
▌
Resonate Lovable Usage Prompt Typescript · resonatehq
Specialized guidance for building Resonate applications within Lovable.dev, which is Node.js/React/TypeScript. Use when working with Lovable's AI-assisted development environment to scaffold, iterate, and deploy Resonate workflows in the TypeScript SDK.

0
installs
▌
Resonate Supabase Deployments Typescript · resonatehq
Build Resonate workflows on Supabase Edge Functions (TypeScript/Deno) using the Supabase shim, start/probe endpoints, and optional DB progress tracking.

0
installs
▌
Resonate Token Authentication Typescript · resonatehq
Secure Resonate applications with JWT-based authentication and prefix-based authorization. Use for multi-tenant systems, role-based access control, and isolating workers or services from accessing each other's promises.

0
installs
▌
Resonate Basic Durable World Usage Python · resonatehq
Core patterns for writing Resonate durable functions in Python — async/await syntax, Context API reference (run, rpc, detached, promise, sleep, dependency injection), and the determinism rules that make recovery work. Use when writing any function body registered with r.register().

0
installs
▌
Resonate Basic Ephemeral World Usage Java · resonatehq
Use when writing Java code in main(), an HTTP handler, or any entry point that launches or coordinates Resonate workflows from the ephemeral world (the Client API surface, not code inside a durable function). Core patterns for the Resonate Java SDK's Client APIs — building a Resonate instance with the fluent builder (or new Resonate() for local mode), registering durable functions via method references, invoking them top-level with r.run, dispatching remotely with r.rpc, reconnecting to an existing execution with r.get, reading typed vs untyped handles, the promises and schedules sub-clients, per-call options, and stop semantics. Requires Java 21+ (virtual threads). Verified against example-hello-world-java / example-countdown-java / example-recursive-factorial-java and develop/java.mdx (docs PR

0
installs
▌
Resonate Basic Ephemeral World Usage Rust · resonatehq
Core patterns for using the Resonate Rust SDK's Client APIs from the ephemeral world — initializing, registering durable functions with the

0
installs
▌
Resonate Human In The Loop Pattern Python · resonatehq
Implement human-in-the-loop workflows in Python — durable functions that suspend on ctx.promise() until an external actor (webhook, UI, CLI, operator) resolves or rejects. Use when a workflow must wait on an action that doesn't originate from another worker, such as approval gates, manual review, or out-of-band data.

0
installs
▌
Resonate Recursive Fan Out Pattern Python · resonatehq
Implement recursive fan-out in Python for parallel workflow execution — spawn N sub-workflows from a parent, optionally recurse deeper, await results, handle partial failure. Use when processing a tree, batch, or crawl where the work shape is dynamic and each child is independently durable.

0
installs
▌
Resonate Durable Sleep Scheduled Work Java · resonatehq
Implement durable sleep and scheduled/recurring work in Java with Resonate — ctx.sleep(Duration) inside workflows for timers, countdowns, reminders, and long-horizon delays that survive process restarts, plus the top-level r.schedule(...) cron API (and the r.schedules sub-client) for periodic invocation of a registered function. Java's r.schedule(...) is a one-call function-dispatch convenience the Go SDK doesn't have yet (Go 0.1.0 has the lower-level Schedules() sub-client instead). Use when a workflow must wait for hours or days, or when a function should run on a fixed cron schedule. Verified against example-countdown-java / example-quickstart-java and develop/java.mdx (docs PR

0
installs
▌
Resonate Durable Sleep Scheduled Work Rust · resonatehq
Implement durable sleep and cron-scheduled work in Rust with Resonate — ctx.sleep(Duration) inside workflows for timers/countdowns/reminders, resonate.schedule() from the ephemeral world for cron-style recurring invocations. Use when a workflow must wait for hours or days, or when a function should run on a fixed schedule. SDK in active development (0.6.0 on crates.io); API surface may change between releases.

0
installs
▌
Resonate Basic Ephemeral World Usage Python · resonatehq
Core patterns for using the Resonate Python SDK's Client APIs from the ephemeral world — initializing, registering durable functions, invoking them top-level (run / rpc / schedule-adjacent), setting dependencies, and managing external promises. Use when writing any process-level Python code that needs to launch or coordinate Resonate workflows.

0
installs
▌
Resonate Basic Durable World Usage Typescript · resonatehq
The Resonate TypeScript SDK's Context API reference for durable generator functions — ctx.run, ctx.rpc, ctx.sleep, ctx.promise, determinism rules, and structured concurrency. Use once you've decided to use Resonate and are writing code inside function* bodies. For the conceptual decision of whether to use durable execution at all, see the durable-execution skill.

0
installs
▌
Resonate External System Of Record Pattern Go · resonatehq
Maintain consistency between a Resonate Go workflow and an external system that owns the truth — a database, ledger, or third-party API — without distributed transactions, by wrapping every interaction with that system in its own idempotent ctx.Run step so the durable promise records the result and replay never re-fires the external call. Verified against the resonate-sdk-go 0.1.0 tag.

0
installs
▌
Resonate Human In The Loop Pattern Typescript · resonatehq
Implement human-in-the-loop workflows where durable functions pause for human decisions, approvals, or reviews. Use this pattern for approval gates, manual review workflows, and human-assisted processes.

0
installs
▌
Resonate Recursive Fan Out Pattern Typescript · resonatehq
Implement recursive fan-out patterns for parallel workflow execution. Use when breaking down complex work into independent subtasks that execute recursively with automatic deduplication and load balancing.

0
installs
▌
Resonate Basic Ephemeral World Usage Typescript · resonatehq
Core patterns for using Resonate Client APIs in the Ephemeral World - initialization, registration, top-level invocations, promise management, and dependency injection. Covers connecting to a Resonate Server, running on Postgres with no server process (PostgresNetwork), and token authentication - the constructor takes `token`, not `auth`, and silently ignores unknown options. Use this for application entry points and orchestration code outside of durable functions.

0
installs
▌
Resonate External System Of Record Pattern Java · resonatehq
Maintain consistency between a Resonate Java workflow and an external system that owns the truth — a database, ledger, or third-party API — without distributed transactions, by wrapping every interaction in its own idempotent ctx.run step so the durable promise records the result and replay never re-fires the external call. Uses type-keyed dependency injection (r.withDependency / ctx.getDependency) to reach the SoR client, and idempotency keys derived from ctx.info().id(). Verified against develop/java.mdx (docs PR

0
installs
▌
Resonate External System Of Record Pattern Rust · resonatehq
Resonate External System of Record Pattern — Rust

0
installs
▌
Resonate Durable Sleep Scheduled Work Typescript · resonatehq
Implement durable sleep and scheduled work patterns for long-running timers, countdowns, scheduled notifications, and delayed execution. Use ctx.sleep() for delays that survive crashes and span hours, days, or weeks.

0
installs
▌
Resonate External System Of Record Pattern Python · resonatehq
Maintain consistency across external systems in Python Resonate workflows by treating one system as the source of truth and writing to it idempotently before any dependent effects. Use when Resonate's durable promises coordinate writes to PostgreSQL, TigerBeetle, Kafka, or any external store that has its own durability contract.

0
installs
▌
Resonate External System Of Record Pattern Typescript · resonatehq
Maintain consistency across multiple systems without distributed transactions using the "Write Last, Read First" principle. Use when integrating with external systems of record that can't participate in transactions.

0
installs

60 published skills