Use kyrie from Claude Code

kyrie is MCP-native. Add it to Claude Code and your agent can define durable tasks, run them, start flows, and read run timelines — the same API a human uses. Claude does the thinking; kyrie makes the doing durable.

This takes about two minutes.

What you’ll need

Claude Code installed (claude on your PATH).
A kyrie API key (kyrie_sk_live_…) from your dashboard.
For the self-hosted path only: Deno and a checkout of the kyrie MCP server.

1. Add kyrie to Claude Code

Hosted kyrie (recommended). One command points Claude Code at the kyrie MCP endpoint with your key:

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

Self-hosted / local. Run the MCP server over stdio against your own kyrie:

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 /path/to/kyrie_mcp/server.ts

Share it with your team. Add --scope project to write a committable .mcp.json at your repo root:

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

Keep real keys out of a committed .mcp.json — use an env var reference or the hosted --header form for shared setups.

2. Verify it connected

claude mcp list

Or inside a Claude Code session, run /mcp — you’ll see kyrie with its tool count once it’s connected.

3. Build a durable task — just ask

With the server connected, Claude Code can drive kyrie for you. For example:

> Create a kyrie task that POSTs to https://api.example.com/charge,
  then run it with {"amount": 50} and show me the result.

Claude:
  • kyrie_create_task → "charge_customer" (customer.http)
  • kyrie_run_task    → run_abc123
  • kyrie_get_run     → COMPLETED  { "id": "ch_1Q…", "amount": 50 }
  Done — the task is defined and the run completed.

Go further — Claude can compose durable, human-in-the-loop workflows:

> Define a kyrie script task that charges the card in a ctx.step, then
  waits for manager approval with ctx.waitFor, and run it.

> Start the "vet_draft" flow for draft 42 and show me the per-step timeline.

The agent is now building on durable execution — completed steps are memoised (they survive a crash and never re-run), runs can pause for a human, flaky calls retry safely, and everything is on the run timeline.

What Claude can do through kyrie

Tool	What it does
`kyrie_create_task`	define / version a task (HTTP or script)
`kyrie_run_task`	invoke a task, now or scheduled
`kyrie_get_run` · `kyrie_list_runs`	read run state, timeline, output
`kyrie_cancel_run`	cancel a scheduled / queued run
`kyrie_start_flow` · `kyrie_get_flow_run`	start a flow, read its per-step timeline
`kyrie_list_tasks` · `kyrie_list_flows`	browse what’s defined
`kyrie_put_secret`	store a secret the tasks can use

Why this matters

An agent is brilliant at reasoning but ephemeral — when its process ends or crashes, in-flight work is lost, and it can’t natively pause for a human for hours or run itself on a schedule. kyrie is the durable layer underneath the agent’s actions: each action is a step that runs once and resumes after a crash, can wait for human approval at zero cost, retries safely, and can schedule recurring work — all observable.

Your agent can give itself durable execution.

See the full durable model in action in the Beacon study, or open the app to get a key.