O.T.T.O Orchestrating Tasks and Task Operations
Download for macOS
PRODUCTIVITY SUITE FOR CODING WITH AGENTS · macOS

Multiply your output.
Without lowering the bar.

Your agents got fast. Your workflow didn't. OTTO is the suite around them — parallel work in isolated checkouts, review wired into every handoff, and a session that remembers what was decided. Volume goes up. Accuracy holds, because nothing lands without a step that checks it.

Download for macOS See a workflow run Bring your own agents. Free while in beta.
workflow · end to end run 41
your request plan review build review test needs fix needs fix Claude Code Codex CLI Claude Code Codex CLI opencode
Draw the handoffs once. Agents route themselves.
needs fix goes back to the builder, not forward.
OTTO DOES NOT SHIP AN AGENT. IT RUNS THE ONES YOU ALREADY HAVE.
Claude Code
Claude Code
anthropic · full TUI in a pane
installed · v2.1.4
Codex CLI
Codex CLI
openai · plan, build, review — any node
installed · v0.9.2
opencode
opencode
open source · any provider
installed · 0.4.11
ONE AGENT, THEN FIFTEEN MORE ALREADY RUNNING replay ↻
surplus-intelligence Terminals Workflows ~/Projects/surplus-intelligence 16 running · 16/16 panes
Codexcodex · agent-01
$ codex review
diff otto/agent-01
 parser.ts  +18 −4
outcome: done
Claude Codeclaude · agent-02
● Grep "toCents("
  23 matches · 9 files
● Edit money.ts
  +41 −18
opencodeopencode · agent-03
writing migration
0142_money_minor.sql
 backfill 2.1M rows
Claude Codeclaude · agent-04
● Bash npm test
  ✓ 68 passed 4.2s
  ! 1 flaky
Codexcodex · agent-05
reading webhooks/
 retry.ts   +7 −7
finding: no backoff
outcome: needs fix
Claude Codeclaude code · 06wt-06
✻ Claude Code v2.1.4
> use the new Money type
● Edit billing/adapter.ts
  +41 −18
● Bash npm test -- billing
  ✓ 68 passed
opencodeopencode · agent-07
plan
 1. add amount_minor
 2. backfill
 3. drop amount
Claude Codeclaude · agent-08
● Read AGENTS.md
● Read docs/api.md
  planning 6 steps
Codexcodex · agent-09
$ codex --model o4-mini
triage 14 open issues
 labelled 11
Claude Codeclaude · agent-10
● Edit ui/Table.tsx
  virtualised rows
● Bash tsc --noEmit
  clean
opencodeopencode · agent-11
sweeping imports
 47 files rewritten
 0 cycles left
Claude Codeclaude · agent-12
● Read migrations/
  waiting on agent-03
  blocked
Codexcodex · agent-13
reviewing agent-10
 Table.tsx  +212 −60
outcome: done
Claude Codeclaude · agent-14
● Write CHANGELOG.md
● Bash git commit
  2 commits
opencodeopencode · agent-15
bench harness
 p95 142ms → 88ms
 wrote report.md
Claude Codeclaude · agent-16
● Grep TODO(otto)
  9 matches
  opening 9 issues

THE PROBLEM, IN THREE LINES

The agent is not the bottleneck any more. You are.

One terminal, one agent, one thread. You sit and watch a single agent think, and when it finishes you paste its output into the next one by hand. You are the message bus, the scheduler, and the merge queue.

Agents are cheap and parallel. Attention is expensive and serial.

Every design decision in OTTO follows from that line.

16
agents per workspace, each a real terminal
3
backends side by side — Claude Code, Codex, opencode
1:1
a git worktree per agent — isolation guaranteed by git
workflows that loop, not just fan out

01 · THE GRID

Real CLIs, in real pseudo-terminals, drawing their own interfaces.

Nothing here is a wrapper or a re-implementation. It is the agent you already use, with its full TUI, in a pane you can type into. Split horizontally or vertically, up to sixteen.

  • Claude Code, Codex and opencode in the same grid
  • Full colour, full TUI, full scrollback
  • Drag images and files straight into any agent
  • Take over any pane mid-run and type at it yourself
Claude CodeClaude Codeotto/agent-06 · worktree wt-06
✻ Welcome to Claude Code v2.1.4
cwd: ~/Projects/surplus-intelligence/.otto/wt-06

CodexCodex CLIotto/agent-05 · read-only for this node
OpenAI Codex v0.9.2
model: o4-mini · sandbox and permissions set per node

opencodeopencodeotto/agent-03
opencode 0.4.11
provider: anthropic · ~/.otto/wt-03

02 · ISOLATION

A git worktree per agent. Isolation you can prove.

Sixteen agents editing one directory would overwrite each other silently — no conflict, no error, no warning. So every terminal gets its own worktree and its own branch. That is not bookkeeping OTTO does carefully; it is git's own guarantee.

ONE TRUNK · SIXTEEN BRANCHES
main

An agent that did nothing leaves no branch behind. An agent that committed keeps its work.

zsh · verifiable, not asserted
$ git worktree list
/repo                  3f9a1c2 [main]
/repo/.otto/wt-01      3f9a1c2 [otto/agent-01]
/repo/.otto/wt-02      3f9a1c2 [otto/agent-02]
/repo/.otto/wt-03      3f9a1c2 [otto/agent-03]
…13 more

# from inside wt-02:
$ git checkout otto/agent-01
fatal: 'otto/agent-01' is already checked out
at '/repo/.otto/wt-01'

# git refuses. That is the guarantee.

03 · WORKFLOWS

A canvas where agents route themselves.

Each node is an agent with its own role, brief, required reading, scope and limits. Each named outcome it can finish with is an outlet you wire to whatever happens next — including back to an earlier node.

A STATE MACHINE, NOT A DAG

A DAG can't express the thing you actually want: the reviewer rejected it, so go back to the builder. A workflow is a walk — run a node, read its outcome, follow that edge.

End to End + agent+ gate+ end repeat limit 3 export · delete workflow
What you asked for
add rate limiting to the public API
PlanClaude Codeclaude
● Read AGENTS.md
● Read docs/api.md
  6 steps · 3 files
outcome: done
▪ done▪ failed
Plan ReviewCodexcodex · read-only
reading plan.md
 no burst allowance
 429 body unspecified
outcome: needs fix
▪ done▪ needs fix
ImplementationClaude Codeclaude
waiting for plan
 scope: src/http/**
 limit: no schema edits
▪ done▪ failed
Implementation ReviewCodexcodex
read-only reviewer
 cannot edit the diff
 it is judging
▪ done▪ needs fix
TesterClaude Codeclaude
runs the suite
 own worktree
 own branch
Finished
finished
needs fix ↑
needs fix ↑
What do you want this workflow to do? This becomes the request every step is given. Run ↵
Agents stay alive between nodes

Returning to a node resumes that agent's session and passes only what changed — a reviewer's second pass doesn't start from a blank slate.

Take over, mid-run

Drop into the exact live terminal the agent is running in and type at it. Hand the run back to the workflow on any outlet.

Cheap model to triage, strong one to build

Backend and model are per node. Every field is editable in the app — never by hand-editing JSON.

04 · PERSISTENCE

Your account, not your disk.

Workspaces, pane layouts, workflows, run history and the agents' own transcripts follow you. A workspace is identified by its git remote rather than a filesystem path — so the same project resolves wherever it happens to live.

MacBook Pro · 21:04 · closing
claude · agent-01
● Edit rate.ts
  mid-thought
codex · agent-02
reviewing…
opencode · 03
migration draft
claude · agent-04
✓ 68 passed
resolved by git remote
github.com/acme/api
layouts · workflows · run history · transcripts
Mac Studio · 09:12 · reopened
claude · agent-01
● resumed session
  continuing rate.ts
codex · agent-02
reviewing…
opencode · 03
migration draft
claude · agent-04
✓ 68 passed

Verified, not assumed: an agent taught a fact on one machine recalls it on another. In build now — carrying local-only commits and uncommitted work across machines too.

ON THE WAY not shipped yet — listed so you know where this goes

The rest of the loop, in build.

Push to talk — speak to your agents

Hold a key. Talk. The focused agent receives it as text — or broadcast the same instruction to a selected group. Punctuation and code identifiers handled properly, so you are not correcting the transcript.

~150
wpm speaking
vs
~40
wpm sustained typing
Instruction is the one part still gated on your hands. It compounds across sixteen panes.
Analytics — see the compression

Most productivity claims are vibes. OTTO already sees every agent-second, run and word: parallelism multiplier, dead time reclaimed, the node that fails most, cost per landed change.

compression · 3.3 agent-hours in 40 minutes of yours
Illustrative shape only. Real numbers come from real usage.
The landing lane

Sixteen agents produce sixteen branches, and the queue just moves. Every diff side by side, conflicts surfaced before you merge, a suggested landing order, one place to approve or send work back.

Spend governor · shared library

A budget per run, per workflow or per day — enforced, not reported. A projection before you press run. And workflows you publish, version and fork across your org.

Where OTTO differs

Everything else helps one agent do one thing well. OTTO is what you need once that stopped being your constraint.

ALTERNATIVE
WHAT IT IS
WHERE OTTO DIFFERS
A single agent CLI
One agent, one terminal
Runs sixteen of them, and orchestrates the handoffs
AI-native IDEs
An editor with an assistant inside
Not an editor. The layer above: many agents, isolation, routing
Node-based AI canvases
Pull-based graphs, run once, no branching
A walk with conditional routing and loops — each node a real agent in a real repo
Terminal multiplexers
Panes, and nothing else
Knows what an agent is: worktrees, sessions, outcomes, resumption

What OTTO is not, today

You would find these out in ten minutes anyway.

  • macOS only. Windows and Linux are not shipped.
  • Bring your own agents. A cockpit, not a model provider.
  • Agents run on your machine. What moves between machines is the conversation and the work, not a running process.
  • Sixteen agents can spend real money. The spend governor is planned, not shipped.
  • Requires connectivity. So do the agents themselves.
  • The ceiling is not sixteen. Reviewing sixteen streams is its own skill — most people find their number is smaller.

Stop being the message bus.

Draw the handoffs once. Let sixteen agents work at the same time.

Download for macOS macOS 14+ · Apple silicon · one of Claude Code, Codex or opencode installed