A love letter to maintainable system

open source

Your agent already figured it out.
Stop paying it to do it again.

Cori records the workflow your agent designed — chat once, get a typed TypeScript runbook on disk. Runs on Temporal. Zero LLM at runtime unless you put it there. Local first. MIT license. No SaaS dashboard, no demo call, no nonsense.

$ curl -fsSL https://cli.cori.do/install.sh | bash

Star on GitHub Or read the 60-second tour ↓

real output. €0.00.

cori demo · ~/projects

$ cori demo
Running hello_world...
✓ step 1: fetch_quote  (cli, 0.4s, €0.00)
✓ step 2: count_words  (code, 0.0s, €0.00)
✓ step 3: format        (builtin, 0.0s, €0.00)
Done.

  "The best way out is always through." — Robert Frost (8 words)

Total: 0.5s, €0.00.
$

The grumble

“

Your agent figured out how to translate a product sheet on call #1. By call #10,000, you’re still paying an LLM to re-derive the same answer — slowly, expensively, and non-deterministically.

That’s the bug. The workflow is not the conversation. The workflow is the code that fell out of the conversation. Cori writes that code down, types it, tests it, and runs it like any other program in your repo. Same output. A fraction of the cost. Predictable in a way a runtime LLM never will be.

— me, after my third $4k Anthropic bill

How it works

Design once with an agent. Own the code. Run it deterministically.

Design with an agent.

Talk to Claude Code, Cursor, or any MCP-capable agent. When the work is done, type save_workflow. Cori’s skill writes a typed TypeScript runbook to disk — manifest, step files, fixtures.

// in your agent chat
> save_workflow

writing runbook:
  translate_product_sheets_fr/
  ├── manifest.toml
  ├── steps/
  └── fixtures/

Inspect and own the code.

Every step is a typed function: cli, mcp_tool, code, llm, or a builtin for flow control. No magic strings, no hidden prompts. Read it, edit it, test it with vitest.

// steps/03_check_gpsr.ts
export default step.code({
  id: "check_gpsr",
  input: SheetSchema,
  output: GpsrResult,
  run: async ({ input }) => {
    // ...
  },
});

Run it deterministically.

cori run translate_product_sheets_fr. Each step executes on Temporal — retries, timeouts, and durable state out of the box. The only LLM calls are the ones you explicitly declared.

$ cori run translate_product_sheets_fr
✓ fetch_sheet   (cli, 0.2s, €0.00)
✓ normalize     (code, 0.0s, €0.00)
✓ check_gpsr    (code, 0.0s, €0.00)
✓ translate     (llm, 1.8s, €0.004)
Total: 2.1s, €0.004

Architecture

How it actually works.

Cori bundles Temporal for local development. Activities run in your own environment — CLIs you have installed, MCP servers you’ve connected, LLM providers you’ve configured. Cori v1 is local-first; there is no cloud worker.

Five activity kinds. That’s the whole API.

Every step is one of five things.
No sixth thing is coming.

cli

Shell out to a command-line tool you already trust.

step.cli({ cmd: "rg", args: ["-l", q] })

mcp_tool

Call any tool exposed by a connected MCP server.

step.mcp_tool({ server: "fs", tool: "read_file" })

code

Run pure TypeScript. The everyday workhorse.

step.code({ run: async ({ input }) => ... })

llm

An explicit, declared LLM call. Typed in, typed out.

step.llm({ model: "claude-opus-4.7", schema })

builtin

Flow control: map, branch, retry, parallel, wait.

step.builtin({ kind: "map", over: "items" })

✂ — — — flip the page — — —

This isn’t another agent framework.

Them

Agent frameworks make agents more capable at runtime.
They re-derive the workflow on every call. The LLM is the runtime. The bill arrives monthly.

Cori captures the workflow once and runs it as code. The LLM is the design tool. Runtime is deterministic, testable, and so cheap you forget to look at the bill.

Both approaches have a place. Cori is the one you reach for when a workflow is going to run 1,000+ times, the output shape is stable, and the cost of running an LLM in the loop has become real.

Get started

no signupno creds

Three commands.
Under a minute.

$ curl -fsSL https://cli.cori.do/install.sh | bash
01Install Cori (Linux, macOS, Windows via WSL).
$ cori demo
02Run the bundled hello_world workflow end-to-end. No credentials.
$ cori skill install --agent claude-code
03Drop the Cori skill into Claude Code so it can save your next conversation as a runbook.

Don’t have Claude Code? Cori also works with Cursor, Gemini CLI, and Copilot CLI see the install flags →

LICENSEMIT licensed.
LOCAL-FIRSTYour code, your CLIs, your LLM keys, your machine.

Star on GitHub

Your agent already figured it out.Stop paying it to do it again.