An open orchestration layer for coding agents.

operad

$ operad pending
4c1e9a02  dev  confirm
  Rotate the http token
  waiting: ready to merge
  actions: dev:merge, dev:reject, dev:rework,
           dev:reverify, dev:cancel

$ operad dev:merge T-0022-token-rotate --yes

$ operad history T-0022-token-rotate
- 22:28:40  review  pass  58s
- 22:30:02  you chose merge

Pending3

Rotate the http tokenT-0022-token-rotate
ready to merge
Stop serve cleanlyT-0023-serve-stop
review findings
Channel for Claude CodeT-0024-mcp-channel
work did nothing
Theme files for the TUIT-0021-tui-themes
running

A kernel with three words: flow, pending, history.

Everything else is a plugin.

Plan, work, verify, review, merge.

You ask

Describe a request with operad plan add, split it into tasks with operad task add, then confirm the plan.

An agent works

Each task gets its own git worktree and a brief. The worker commits there.

Checks run

The commands you list in .operad/dev.json run against the commit.

An agent reviews

A reviewer reads the change and writes a report. Findings send the task back for rework, up to a limit.

You merge

The task waits in pending. Merge lands it on main; reject sends it back with your note.

Any agent can work, and any agent can review.

claude, pi and radian are the workers the repository has plugins for. Each is a plugin you enable; pick them per repository, one for the worker and another for the reviewer.

// .operad/dev.json
{
  "worker":   { "use": "claude/agent",
                "args": ["--model", "sonnet"] },
  "reviewer": { "use": "pi/agent",
                "args": ["--thinking", "medium"] }
}

The kernel is three words.

flow

The path a piece of work follows: steps, a wait for you, a wait for time, an end. operad flows lists the ones that are loaded.

pending

Everything that waits for you, in one list, with the actions each item offers.

## dev run · started 21:38
**2026-11-08**
- 21:38:41  worktree  ready  1s
- 21:38:44  work  done  41m
- 22:20:01  review  fail  58s
- 22:21:01  work  attempt 2  after fail
- 22:22:02  confirm  reverify  8m
- 22:30:02  you chose merge

history

words you learn. Every other word belongs to a plugin, so you never meet the ones you don't use.

dev plan, task, review, merge
chat a long conversation with an agent
bot a directory, an agent, skills
pool shared limits for each agent

Plugins are TypeScript files, loaded without a build step, small enough for an agent to write on the spot.

A plugin is type-checked before it runs.

operad plugin check

What waits for you is one list.

Example tasks. Choose a row; merge or reject the ones waiting.

Landed on main. The task's worktree and branch are cleaned up.
```
- 20:12:09  merge  done  4s
- 20:12:14  cleanup  done  1s
```
The checks are running on the worker's commit.
```
- 21:40:31  verify  running  2m
```
A worker is committing in the task's worktree.
```
- 21:38:44  work  running  11m
```
Verify passed and the reviewer found nothing that blocks. It waits for you.
```
- 22:20:01  verify  pass  8m
- 22:28:40  review  pass  58s
- 22:28:41  waiting: ready to merge
```
The reviewer's findings wait for your choice: rework, reject or merge anyway.
```
- 22:01:12  review  fail  58s
```
The worker added no commit. Send it back with a note, or cancel.
```
- 22:03:50  work  done  3m
```
Waiting for T-0022-token-rotate to merge.

Terminal, Claude Code, iPhone.

The terminal client.

operad tui finds operad serve or starts it, lists what is pending and running, and opens an object beside the list. a runs the main action, : opens the palette, q quits.

Claude Code, over MCP.

operad mcp is an MCP server on stdio. A lead agent reads pending, running and history, runs plugin commands, and takes the actions config.json allows. It never takes your decision: merge stays with you.

Its tools are list, show, section, pending, answer, running, history, command and act.

// .mcp.json
{ "mcpServers": {
    "operad": { "command": "operad",
                "args": ["mcp"] } } }

The iPhone app.

Run operad pair and scan the code. The app shows pending, running, each object's sections and its history, and asks before it merges. The server listens on this machine unless you give it a LAN or Tailscale address.

$ operad pair
url http://192.168.1.20:7480
token <the token>

Scan this in the operad app:

Run it on your own machine.

operad is in development. This is how its own repository runs on it.

operad init
operad repo add .
operad plan add --slug dogfood --title "Run operad on operad" < request.md
operad task add --plan P-0001-dogfood --slug switch --title "Switch" < task.md
operad dev:confirm P-0001-dogfood
operad serve

operad pending
operad dev:merge T-0001-switch --yes

You need git, a repository with a remote, the Bun runtime, and one of claude, pi or radian on your PATH. The commands and config.json keys are in docs/manual.md in the repository.

Source on GitHub