Cori
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 workflow 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.

Download Coriv0.3.2
Star on GitHub
Free · open source · no signupOr read the 60-second tour ↓
point. click. €0.00.
Cori
acme/flowsremote
Recents
  • translate_product_sheets_frsucceeded12 min ago · ~/flows/translate
  • sync_inventorysucceeded2 h ago · github.com/acme/flows@v2
  • weekly_kpi_reportsucceededMon 09:00 · schedule
ReadyHistorySchedules
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.

Agent → workflow

The path is traced. Every run after follows it.

Your agent already searched its way through the problem once. Cori captures that route as a typed workflow — so every similar task after walks the line your agent already drew.

Agent traced onceCori execute forever
How it works

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

01

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 workflow to disk — manifest, step files, fixtures.

// in your agent chat
> save_workflow

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

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 deno test.

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

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.

DESIGN TIMECOMPILE TIMERUN TIMEAgent + Cori skillClaude Code · Cursor · MCP→ save_workflow→ Workflow on diskmanifest.toml · steps/*.tscori workflows registerCompiler validates typesLocal registry (SQLite)no network requiredcori runTemporal worker (local)Activities:cli · mcp_tool · code · llm · builtinyour agentyour machineyour environment

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.

Us

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

One download.
Under a minute.

  1. Download Coriv0.3.2

    01Download Cori. The app bundles the whole engine — no runtime to install, nothing else to configure.

  2. ⌘L cori-do/workflows

    02Open the launcher, paste this reference, press Enter, and run hello_world. No credentials.

  3. $ npx skills add cori-do/cori

    03Drop the Cori skill into Claude Code so it can save your next conversation as a workflow.

Live in the terminal? The launcher’s footer has an Install CLI button that puts the cori command on your PATH. And the skill works beyond Claude Code — Cursor, Gemini CLI, and Copilot CLI too see the install flags →

  • LICENSEMIT licensed.
  • LOCAL-FIRSTYour code, your CLIs, your LLM keys, your machine.
Star on GitHub