Durable execution for AI agents.
Give kyrie your code. It runs reliably — retries on failure, remembers progress, pauses for human approval, and notifies — without you running a single server.
// A run that survives crashes, never double-charges, and waits for a human.
export default async (order, ctx) => {
// runs once — memoized across retries & resumes
const charge = await ctx.step("charge", () => stripe.charge(order));
// parks the run for hours at zero cost, then resumes here
const ok = await ctx.waitFor("manager-approval");
return { charged: charge.id, approved: ok.approve };
};The hard parts, handled.
Durable workflows usually mean queues, retries, idempotency keys, a scheduler, and a state machine. On kyrie they’re a few lines of business logic.
| The hard part | Normally | On kyrie |
|---|---|---|
| Don’t re-charge / re-publish on retry | Hand-rolled idempotency + dedupe tables | ctx.step() — runs once, ever |
| Survive a crash mid-workflow | A saga / state-machine + recovery code | The run resumes from its last step |
| Pause for a human for hours | A queue + a “waiting” table + a worker | ctx.waitFor(key) → ResolveRun |
| Retry flaky HTTP safely | Backoff + max-attempts + poison handling | Transient steps retry; memo keeps the rest |
| Recur every X without drift | Cron + locking + overlap guards | Self-rescheduling run + idempotency_key |
Three nouns. That’s the model.
Define the work once
A unit of work — an HTTP call, a wasm module, or a TypeScript function — with an input and output schema.
Trigger an execution
Each run is recorded, retried, and resumable. Watch every step, retry, and wait on the timeline.
Chain tasks into a pipeline
A DAG that maps outputs between steps, runs independent steps in parallel, and branches on failure.
Three primitives, one platform.
Mix them freely inside a flow — call the messy outside world, run deterministic compiled logic, and orchestrate it all durably.
customer.http Call anything
Hit any URL or third-party/LLM API with a guarded HTTP step. Templated inputs, injected secrets, automatic retries on transient failure.
customer.wasm Run compiled logic
Ship a sandboxed WebAssembly module for deterministic, auditable computation — scoring, validation, policy. Same input, same answer, every time.
customer.script Orchestrate in TypeScript
Write durable TypeScript with ctx.step and ctx.waitFor. Memoized steps, crash-safe resume, and pause-for-a-human built in.
What you get for free.
Never double-pay
ctx.step memoizes — an expensive call runs once, even across retries and crashes.
Survive crashes
A killed worker resumes the run from its last completed step. No lost progress.
Pause for humans
ctx.waitFor parks a run at zero cost for hours or days, then resumes exactly where it left off.
Safe flaky integrations
Transient failures retry with backoff, without re-running the work that already succeeded.
Recurring without cron
Compose schedules from self-rescheduling runs with idempotent re-arms — no extra infra.
Runs untrusted code
Deno and wasmtime sandboxes with SSRF-guarded egress execute customer code safely.
Built for agents — works with Claude Code.
Agents are brilliant but ephemeral — when the process ends or crashes, in-flight work is lost. kyrie is the durable layer underneath an agent’s actions, and it’s MCP-native, so Claude Code can drive it directly.
Claude does the thinking
Your agent reasons, plans, and decides what to do next — with Claude or any model.
kyrie makes the doing durable
Every action is a durable step: it runs once, resumes after a crash, retries flaky calls, pauses for human approval, and can schedule itself — all observable.
MCP-native
Add kyrie to Claude Code (or any MCP client) and the agent gets tools to define tasks, run them, start flows, read run timelines, and manage secrets — the same API a human uses. Your agent can give itself durable execution.
- kyrie_create_task
- kyrie_run_task
- kyrie_start_flow
- kyrie_get_run
- kyrie_list_runs
- kyrie_put_secret
{
"mcpServers": {
"kyrie": {
"command": "deno",
"args": ["run", "--allow-net", "--allow-env",
"kyrie_mcp/server.ts"],
"env": { "KYRIE_API_KEY": "kyrie_sk_live_…" }
}
}
}Beacon: a durable AI content-publishing agent
One workflow that exercises the entire platform — HTTP + wasm + TypeScript in a flow, a human-approval gate, notifications, and a recurring self-rescheduling job. All 19 acceptance checks pass against the live engine — including a real worker crash.
Usage-based pricing.
Pay for what you run. Two simple meters, a free tier to start, no servers to provision.
Executions
Every run, flow step, and notification. The core meter for orchestrated work.
Sandbox compute
Only for code you run in the script and wasm sandboxes. Waits are free.
Ship durable workflows today.
Define a task, trigger a run, and let kyrie handle the retries, resumes, waits, and notifications.