kyrie aus Claude Code nutzen

kyrie ist MCP-nativ. Füge es zu Claude Code hinzu, und dein Agent kann dauerhafte Tasks definieren, ausführen, Flows starten und Run-Timelines lesen — dieselbe API, die auch ein Mensch nutzt. Claude denkt; kyrie macht das Tun dauerhaft.

Das dauert etwa zwei Minuten.

Was du brauchst

Claude Code installiert (claude im PATH).
Einen kyrie-API-Key (kyrie_sk_live_…) aus deinem Dashboard.
Nur für den Self-Hosting-Weg: Deno und einen Checkout des kyrie-MCP-Servers.

1. kyrie zu Claude Code hinzufügen

Gehostetes kyrie (empfohlen). Ein Befehl richtet Claude Code mit deinem Key auf den kyrie-MCP-Endpunkt:

claude mcp add --transport http \
  --header "Authorization: Bearer kyrie_sk_live_…" \
  kyrie https://mcp.kyrie.sh/mcp

Self-Hosting / lokal. Führe den MCP-Server über stdio gegen dein eigenes kyrie aus:

claude mcp add --transport stdio \
  --env KYRIE_URL=http://localhost:8093 \
  --env KYRIE_API_KEY=kyrie_sk_live_… \
  kyrie -- deno run --allow-net --allow-env /pfad/zu/kyrie_mcp/server.ts

Mit deinem Team teilen. Füge --scope project hinzu, um eine committbare .mcp.json im Repo-Root zu schreiben:

{
  "mcpServers": {
    "kyrie": {
      "type": "stdio",
      "command": "deno",
      "args": ["run", "--allow-net", "--allow-env", "/pfad/zu/kyrie_mcp/server.ts"],
      "env": {
        "KYRIE_URL": "http://localhost:8093",
        "KYRIE_API_KEY": "kyrie_sk_live_…"
      }
    }
  }
}

Halte echte Keys aus einer committeten .mcp.json heraus — nutze eine Env-Variablen-Referenz oder die gehostete --header-Form für geteilte Setups.

2. Verbindung prüfen

claude mcp list

Oder führe in einer Claude-Code-Sitzung /mcp aus — du siehst kyrie mit seiner Tool-Anzahl, sobald es verbunden ist.

3. Einen dauerhaften Task bauen — einfach fragen

Mit verbundenem Server kann Claude Code kyrie für dich steuern. Zum Beispiel:

> Erstelle einen kyrie-Task, der an https://api.example.com/charge POSTet,
  führe ihn dann mit {"amount": 50} aus und zeig mir das Ergebnis.

Claude:
  • kyrie_create_task → "charge_customer" (customer.http)
  • kyrie_run_task    → run_abc123
  • kyrie_get_run     → COMPLETED  { "id": "ch_1Q…", "amount": 50 }
  Fertig — der Task ist definiert und der Run ist abgeschlossen.

Geh weiter — Claude kann dauerhafte Human-in-the-Loop-Workflows zusammensetzen:

> Definiere einen kyrie-Script-Task, der die Karte in einem ctx.step belastet,
  dann mit ctx.waitFor auf die Freigabe des Managers wartet, und führe ihn aus.

> Starte den Flow "vet_draft" für Entwurf 42 und zeig mir die Timeline pro Schritt.

Der Agent baut jetzt auf Durable Execution — abgeschlossene Schritte sind memoisiert (sie überstehen einen Absturz und laufen nie erneut), Runs können für einen Menschen pausieren, wackelige Aufrufe werden sicher wiederholt, und alles steht in der Run-Timeline.

Was Claude über kyrie tun kann

Tool	Was es tut
`kyrie_create_task`	einen Task definieren / versionieren (HTTP oder Script)
`kyrie_run_task`	einen Task aufrufen, sofort oder geplant
`kyrie_get_run` · `kyrie_list_runs`	Run-Status, Timeline, Output lesen
`kyrie_cancel_run`	einen geplanten / wartenden Run abbrechen
`kyrie_start_flow` · `kyrie_get_flow_run`	einen Flow starten, dessen Timeline pro Schritt lesen
`kyrie_list_tasks` · `kyrie_list_flows`	durchsehen, was definiert ist
`kyrie_put_secret`	ein Secret speichern, das die Tasks nutzen können

Warum das wichtig ist

Ein Agent ist brillant im Denken, aber flüchtig — wenn sein Prozess endet oder abstürzt, geht laufende Arbeit verloren, und er kann nicht von sich aus stundenlang auf einen Menschen warten oder sich selbst nach Zeitplan ausführen. kyrie ist die dauerhafte Schicht unter den Aktionen des Agenten: Jede Aktion ist ein Schritt, der einmal läuft und nach einem Absturz fortsetzt, ohne Kosten auf eine menschliche Freigabe warten kann, sicher wiederholt und wiederkehrende Arbeit planen kann — alles nachvollziehbar.

Dein Agent kann sich selbst Durable Execution geben.

Sieh das vollständige dauerhafte Modell in Aktion in der Beacon-Studie oder öffne die App, um einen Key zu bekommen.