Works with the coding agents your team already uses
- Claude Code
- Codex CLI
- Cursor
- Gemini CLI
- OpenCode
- >_aider
The first five join through their own hooks, so they are gated, swept and steered like any other member. Anything else — aider, a script, a person with an editor — is wrapped by switchboard run. How each harness fits →
Every agent on every machine plugs into one hub.
A laptop in the studio, a desktop at home, a runner in the cloud — each session patches into the same Switchboard. Work is leased, checked and gated there, then lands on a shared branch that stays green. If a session dies mid-task, what it already pushed still lands.
Nobody gets locked out. Nobody gets surprised.
Most tools stop the second agent the moment two people touch the same file. Switchboard treats that moment as information, not an emergency.
- Touch a file and it's yours — quietly.
No checkout, no waiting, no ceremony. The first edit takes a lease on its own.
- Someone else touches it too? Both of you hear about it, once.
Every session works on its own branch, so the second edit goes through. Switchboard notes the overlap, tells each side what the other is doing, and checks whether the two changes can live together.
- A hard no needs proof.
An edit is refused only when there is evidence it cannot land: a real merge conflict on that file, or a verdict that the two changes contradict each other. Every refusal says why, points at free files instead, and expires after 30 minutes.
evidence: merge m_4e12 conflicted on this path 14 minutes ago
expires: 30m · try instead: src/payments/refunds.ts, src/payments/types.ts
appeal: attach a passing merge preview
Verbatim — the same words the agent sees. No hidden state, nothing decided behind its back.
Write the tasks. The room hands them out.
Put tasks on the board with one command. Whenever an agent finishes and has nothing in flight, the conductor gives it the next open task whose dependencies are done — as a prompt from the machine, never from a person. Anything a human types outranks it, and one click on the board pauses it.
switchboard task "Add remember-me to the session cookie" --area backend --paths src/auth/session.ts
Opt in per hub with --conductor on. Off, tasks are simply a shared list agents claim themselves.
The shared branch is green by construction.
Agents hear about the room instantly, but they only receive code at task boundaries — squash-merged through your build and tests onto switchboard/live. A merge that conflicts lands nothing, and becomes the evidence that keeps the next overlap off those files.
What happens to a finished task
Abandoned sessions are reaped: whatever they pushed goes through the same gate, unattended. A dead agent's green work is not lost work.
Also in the room
- Steer any agent from the board. Watch its conversation live and type into it, across machines. Thinking and tool internals never leave the machine they ran on.
- Interfaces agreed before the code exists. Propose a shape, teammates push back inside a settling window, silence is consent.
- Hub unreachable? Nothing stops. Local tiers take over and the room fails open. A coordination layer must never brick a team.
- Catch up, don't replay. Rejoin and the board summarizes what landed while you were away; a digest and a webhook tell the channel.
Two people, two agents, one file.
Maya is on Claude Code, Dev is on Cursor, and both of them need src/auth/session.ts. This is what Switchboard does instead of blocking.
Up in about a minute.
Two packages on npm. The hub runs on one machine; the agent rides in every clone. Node 22.13 or newer for the hub, nothing to build.
See it on your machine
One command stands up a complete room: a fixture repo, a hub, two enrolled clones and four overlapping tasks on a live board. Nothing touches your real repos.
npx switchboard-hub demo
There is no login on the board — the key rides the URL. The same link works on a wall display; it can see everything and touch nothing.
Run it for a real team
npx switchboard-hub up
Starts the hub against your origin, enrols this clone, and prints the board link and the join line for teammates.
switchboard join --hub http://<hub>:7420 --key <join-key>
Exchanges the join key for this clone's own token, stored locally and never committed.
claude
Sessions register on their own through the committed hook config. Open the board link to watch the room.
npx switchboard-hub join-key reprints the key whenever a new teammate needs one. Beyond the LAN, put the hub behind a tunnel or a public URL — the manual covers both.
Codex, Cursor, Gemini CLI, OpenCode — members, not guests
One flag lays down committed hook and MCP config per harness, plus an AGENTS.md section they all read natively. Nothing it writes carries a secret.
# or --for all · anything without hooks, wrapped for the length of its run:
switchboard run -- aider
| Harness | Edits gated | Work swept & landed | Room facts delivered | Steer from the board |
|---|---|---|---|---|
| Claude Code | yes | yes | yes | yes |
| Codex CLI | yes | yes | yes | yes |
| Cursor | shell commands | yes | yes | yes |
| Gemini CLI | yes | yes | yes | no — its hooks have no way in, so the board says so instead of pretending |
| OpenCode | yes | yes | yes | yes |
| aider, scripts, people | printed, not enforced | yes | printed in the terminal | no |
How it works
One hub process coordinates everything. Leases, verdicts, contracts, the merge gate and transcript projections live in a single process; agents talk to it over one HTTP port and the board streams over SSE. If the hub becomes unreachable, local tiers take over and Switchboard fails open.
Two speeds. The decision that can block an edit is deterministic — tiered, no model, under 50 ms at p95. The intelligent work — checking whether two overlapping changes can coexist, assembling handoffs — runs beside the code and arrives at the next safe point.
Identity is a credential, never a claim. A join key enrols a clone; the clone's own token rides every call it makes and is hashed at rest on the hub. A per-person operator token adds steering. A plain board link is a projector: it sees everything and touches nothing.
Transcripts are projections. Prompts, summaries and tool titles reach the board. Thinking and tool internals never leave the machine that produced them.