Autopilot for a fleet of Claude Code agents. They fly the reversible work unattended; a model-free gate stops the fleet before anything that deploys, sends, deletes, or spends — and hands that one call to you. You can look away because it can't ship without you.
Agentic coding made it cheap to run five, ten, fifteen autonomous windows at once. But each one can quietly deploy, send, delete, or spend the moment it decides to — so you can't actually walk away. You sit there alt-tabbing, ready to yank the wheel, doing the one job a fleet was supposed to free you from. The bottleneck isn't compute. It's that you don't trust them to run unwatched.
Conductor lets the reversible work run end-to-end — edits, tests, commits, the back-and-forth
a window can answer for itself. It reads the live .jsonl trail each
Claude Code window already writes under ~/.claude/projects/, so it
knows what every agent is doing without you watching.
This is the whole product. The fleet runs reversible work on its own — but the moment a window's next step would do something irreversible, Conductor physically stops and hands that one decision back to you. Auto-continue is commodity; auto-continue plus a gate you can't cross without a human thumb is the part you can trust. You can look away because it can't ship a deploy or move funds without you.
The bias is to stop when unsure: a false gate costs one manual reply; a false pass can ship a bad
deploy or move real funds. The irreversibility gate lives in policy.js — auditable, no model in the loop.
The cockpit isn't the product — the bounded autonomy is. These are just the three ways to keep one eye on a fleet that's running itself, and to land the calls only you can make.
Run conductor up for a live web view. Every window a card, color-coded by status,
auto-refreshing — so a glance tells you the fleet's still flying and nothing's hit the gate. When
one stops for a yes/no, it surfaces with one-tap Yes / No / Continue / Review.
Conductor speaks the Model Context Protocol over stdio. An orchestrator agent calls
list_sessions, whats_left, pending_questions and the gated
control tools to run the fleet for you — and still can't push past the irreversibility gate.
Drop in the Claude Code skill and any window can tell you the fleet's state in plain English: “what's left across my windows?” → a doing-now / done / waiting-on-you report per session.
Launch managed windows through tmux, or adopt an existing one (forked, history
intact) so Conductor can drive it. Even then, control stops at the gate — and read-only stays read-only.
Conductor is supervisory awareness over a fleet of semi-autonomous workers that already emit an append-only trail. Claude Code is one adapter. Swap the adapter, keep the engine — grouping, status, and all three surfaces come free.
~/.claude/projects transcripts; liveness from a live claude processevents.jsonl; derives wedged orders & drawdown, session PnL
A domain fits when it has all four: many units with intent · a trail that already exists · a liveness
signal · supervise-by-exception status. Write one file at adapters/<name>.js
and every surface works with --adapter <name>.
V1 watches windows you opened by hand. Its sibling
Conductor V2
flips the order: pick a formation, set one purpose, press FIRE —
and a fleet of Claude Code windows launches into tmux and coordinates through two dumb, reliable
channels: a shared swarm directory for artifacts and a per-swarm swarm-say
helper for one-line handoffs. The formation decides who talks to whom and who starts.
┌─ ORC ─┐ ┌───┼───┬───┼───┐ w1 w2 w3 w4
One orchestrator decomposes the mission, delegates a task per worker, collects reports, and synthesizes. Best when the work splits into independent chunks.
s1 ─▶ s2 ─▶ s3 ─▶ s4 each stage hands off to the next
Stages run in order; each consumes the previous stage's output and hands off. Best for a natural assembly line — recon → audit → verify → report.
p1 ─── p2 │ ╲ ╱ │ │ ╱ ╲ │ p3 ─── p4
Equal peers self-organize: each claims a distinct angle, works it, and broadcasts findings to the rest. Best for breadth — sweep a space from several directions at once.
Watching is read-only observation of trails that already exist — nothing leaves your laptop.
The cockpit binds to 127.0.0.1 only.
~/.claude — never another user's transcripts.Wire Conductor into Claude Code at user scope and it's available in every session. Run an orchestrator that flies the fleet — triaging windows, continuing the reversible work, and stopping dead at the gate on anything that deploys, sends, deletes, or spends.
Prefer to watch? npm link puts a global conductor
on your PATH — no build, no dependencies — then one command opens the live web dashboard in your
browser, grouped by status and refreshing every 4s.
No — a tidy dashboard is table stakes (tmux already gives you that). The point is that you can leave. The fleet runs the reversible work unattended, and a hard gate stops it before anything that can't be undone. The cockpit is just where you look when one window finally needs your call. You're buying the ability to look away, not a prettier grid.
No. It reads the .jsonl trail Claude Code already writes under
~/.claude/projects/. Zero instrumentation, zero new infrastructure, zero dependencies.
Other workers (bots, validators) just need a small adapter file.
Not anything irreversible. Ordinary work auto-continues, but the moment a window's question — or a
proposed reply — touches deploy, send, delete, or spend, the gate in
policy.js refuses and returns the reason so a human decides. Approving an irreversible
action is always your call.
No. Everything is local-first. The cockpit binds to 127.0.0.1, reads only your own
~/.claude, and state-changing requests require a local origin plus a CSRF header.
Run it for yourself, not as a service.
Watched, always. Controlled, only if you adopt them — Conductor forks the session into
a managed tmux window (full history intact) so it can inject replies. Plain terminals the OS won't
let anything type into stay read-only, by design.