Durable Execution für KI-Agenten.
Gib kyrie deinen Code. Er läuft zuverlässig — wiederholt bei Fehlern, merkt sich den Fortschritt, pausiert für menschliche Freigaben und benachrichtigt — ohne dass du einen einzigen Server betreibst.
// Ein Run, der Abstürze übersteht, nie doppelt abbucht und auf einen Menschen wartet.
export default async (order, ctx) => {
// läuft einmal — memoisiert über Retries & Resumes hinweg
const charge = await ctx.step("charge", () => stripe.charge(order));
// parkt den Run stundenlang ohne Kosten, dann geht es hier weiter
const ok = await ctx.waitFor("manager-approval");
return { charged: charge.id, approved: ok.approve };
};Die schwierigen Teile — erledigt.
Dauerhafte Workflows bedeuten normalerweise Queues, Retries, Idempotenz-Keys, einen Scheduler und eine State-Machine. Auf kyrie sind es ein paar Zeilen Geschäftslogik.
| Das Schwierige | Normalerweise | Auf kyrie |
|---|---|---|
| Bei Retry nicht doppelt abbuchen/veröffentlichen | Selbstgebaute Idempotenz + Dedupe-Tabellen | ctx.step() — läuft genau einmal |
| Einen Absturz mitten im Workflow überstehen | Eine Saga / State-Machine + Recovery-Code | Der Run setzt beim letzten Schritt fort |
| Stundenlang auf einen Menschen warten | Eine Queue + eine „Warte“-Tabelle + ein Worker | ctx.waitFor(key) → ResolveRun |
| Wackelige HTTP-Aufrufe sicher wiederholen | Backoff + Max-Versuche + Poison-Handling | Transiente Schritte wiederholen; Memo behält den Rest |
| Alle X wiederholen, ohne Drift | Cron + Locking + Overlap-Schutz | Self-rescheduling Run + idempotency_key |
Drei Begriffe. Das ist das Modell.
Die Arbeit einmal definieren
Eine Arbeitseinheit — ein HTTP-Aufruf, ein wasm-Modul oder eine TypeScript-Funktion — mit Input- und Output-Schema.
Eine Ausführung auslösen
Jeder Run wird aufgezeichnet, wiederholt und ist fortsetzbar. Verfolge jeden Schritt, Retry und Wait in der Timeline.
Tasks zu einer Pipeline verketten
Ein DAG, der Outputs zwischen Schritten verbindet, unabhängige Schritte parallel ausführt und bei Fehlern verzweigt.
Drei Primitive, eine Plattform.
Kombiniere sie frei in einem Flow — rufe die unordentliche Außenwelt auf, führe deterministische kompilierte Logik aus und orchestriere alles dauerhaft.
customer.http Alles aufrufen
Erreiche jede URL oder Drittanbieter-/LLM-API mit einem abgesicherten HTTP-Schritt. Getemplatete Inputs, eingespeiste Secrets, automatische Retries bei transienten Fehlern.
customer.wasm Kompilierte Logik ausführen
Liefere ein sandboxed WebAssembly-Modul für deterministische, prüfbare Berechnungen — Scoring, Validierung, Policy. Gleicher Input, gleiches Ergebnis, jedes Mal.
customer.script In TypeScript orchestrieren
Schreibe dauerhaftes TypeScript mit ctx.step und ctx.waitFor. Memoisierte Schritte, absturzsicheres Fortsetzen und Pausieren für einen Menschen — eingebaut.
Was du gratis bekommst.
Nie doppelt zahlen
ctx.step memoisiert — ein teurer Aufruf läuft genau einmal, selbst über Retries und Abstürze hinweg.
Abstürze überstehen
Ein abgestürzter Worker setzt den Run beim letzten abgeschlossenen Schritt fort. Kein verlorener Fortschritt.
Für Menschen pausieren
ctx.waitFor parkt einen Run ohne Kosten für Stunden oder Tage und setzt dann genau dort fort, wo er aufgehört hat.
Sichere wackelige Integrationen
Transiente Fehler werden mit Backoff wiederholt, ohne bereits erledigte Arbeit erneut auszuführen.
Wiederkehrend ohne Cron
Baue Zeitpläne aus self-rescheduling Runs mit idempotentem Re-Arm — ohne zusätzliche Infrastruktur.
Führt fremden Code sicher aus
Deno- und wasmtime-Sandboxes mit SSRF-geschütztem Egress führen Kundencode sicher aus.
Gebaut für Agenten — funktioniert mit Claude Code.
Agenten sind brillant, aber flüchtig — wenn der Prozess endet oder abstürzt, geht laufende Arbeit verloren. kyrie ist die dauerhafte Schicht unter den Aktionen eines Agenten, und es ist MCP-nativ, sodass Claude Code es direkt steuern kann.
Claude denkt
Dein Agent überlegt, plant und entscheidet, was als Nächstes zu tun ist — mit Claude oder jedem Modell.
kyrie macht das Tun dauerhaft
Jede Aktion ist ein dauerhafter Schritt: läuft einmal, setzt nach einem Absturz fort, wiederholt wackelige Aufrufe, pausiert für menschliche Freigaben und kann sich selbst planen — alles nachvollziehbar.
MCP-nativ
Füge kyrie zu Claude Code (oder jedem MCP-Client) hinzu, und der Agent erhält Tools, um Tasks zu definieren, auszuführen, Flows zu starten, Run-Timelines zu lesen und Secrets zu verwalten — dieselbe API, die auch ein Mensch nutzt. Dein Agent kann sich selbst Durable Execution geben.
- 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: ein dauerhafter KI-Agent zum Veröffentlichen von Inhalten
Ein Workflow, der die gesamte Plattform nutzt — HTTP + wasm + TypeScript in einem Flow, ein Freigabe-Gate für Menschen, Benachrichtigungen und ein wiederkehrender self-rescheduling Job. Alle 19 Akzeptanzprüfungen bestehen gegen die laufende Engine — inklusive eines echten Worker-Absturzes.
Nutzungsbasierte Preise.
Zahle für das, was du ausführst. Zwei einfache Zähler, ein kostenloses Kontingent zum Start, keine Server bereitzustellen.
Executions
Jeder Run, Flow-Schritt und jede Benachrichtigung. Der Kernzähler für orchestrierte Arbeit.
Sandbox-Compute
Nur für Code, den du in den Script- und wasm-Sandboxes ausführst. Waits sind kostenlos.
Liefere dauerhafte Workflows — heute.
Definiere einen Task, löse einen Run aus, und lass kyrie die Retries, Resumes, Waits und Benachrichtigungen übernehmen.