Conductor watches Claude Code, Codex, and any worker with an append-only trail. Reversible work can keep moving; a model-free gate stops before anything that deploys, sends, deletes, or spends and hands that call to you.
Agentic coding made it cheap to run five, ten, fifteen autonomous sessions 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 trails your
agent CLIs already write, from ~/.claude/projects/ to
~/.codex/sessions/, 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.
Codex sessions get the same cockpit treatment: project labels, intent, last action, waiting state,
and managed replies. Launch codex-conductor up when your fleet is Codex-first.
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 and Codex are adapters. Swap the adapter, keep the engine — grouping, status, and all three surfaces come free.
~/.claude/projects transcripts; liveness from a live claude process~/.codex/sessions transcripts plus session_index.jsonl; infers project context even when Codex starts from homeevents.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>.
Codex writes durable local transcripts under ~/.codex/sessions.
Conductor turns those trails into the same status model: what is working now, what is open, what is
waiting, and which project a session actually belongs to.
Use this when the active fleet is Claude Code windows, or when you want the broader adapter set for bots, validators, MEV searchers, and sales agents.
Use this when the work is happening in Codex. It reads Codex transcripts, resolves project labels, and exposes the same cockpit and MCP control plane.
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.
V1 watches your Claude windows; V2 fires swarms. The newest sibling, Conductor Camera Monitor, watches cameras. Each RTSP feed becomes an AI detective — a Claude session with a one-line mandate. It samples frames, Claude's own vision does the seeing (no model to train — it watches anything you can describe), a motion gate keeps 24/7 watch cheap, and every finding lands in a hash-chained alert ledger you can verify.
watch front_door: alert when a person appears after 10pm
A person enters frame at night → alert. The same person still standing
there next frame stays quiet — dedup fires only on change.
watch greenhouse: warn when a crop bed looks dry or wilted
No ML model, no labels. If you can describe what "dry" looks like, the detective can flag it — and tell you which bed, with the frame as evidence.
watch line_1: critical if the conveyor is empty for over 30s
Object counts, no-go zones, defects, stoppages — any rule that's easier to say than to train. Escalates honestly: info → warn → alert → critical.
Watching is read-only observation of trails that already exist — nothing leaves your laptop.
The cockpit binds to 127.0.0.1 only.
~/.claude and ~/.codex trails — never another user's transcripts.Wire Conductor into Claude Code or Codex and make it available wherever you orchestrate. 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. Use conductor up for Claude Code
fleets or codex-conductor up for Codex fleets.
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 trails your tools already write, including
~/.claude/projects/ and ~/.codex/sessions/. Zero instrumentation, zero new
infrastructure, zero dependencies. Other workers 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 / ~/.codex, 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.