Every session patches through one exchange.
Agents on different machines plug into the same hub. Work routes through it, gets leased, adjudicated and gated, then lands on switchboard/live. Even the reaped session’s cable still carries.
An evidence ladder, not a lock.
evidence: conflicted merge m_4e12 touched this path 14m ago
expires: 30m · appeal: attach a passing merge preview
Deterministic when it blocks. Intelligent when it can wait.
Every edit gets a tiered, deterministic answer, with no model on the blocking path. The intelligent work, collision adjudication, semantic conflict detection and handoff packets, runs beside the code and arrives at the next safe point.
Always green, by construction.
Agents hear about the room in real time but receive code only at task boundaries, squash-merged through a build gate into switchboard/live. A conflicted merge lands nothing, and it becomes the evidence that denies the next overlap on those paths for 30 minutes.
Abandoned sessions are reaped: their branches land through the same gate, unattended. A dead agent’s green work is not lost work.
Interfaces agreed before the code exists.
Propose a shape. Consumers push back inside a settling window. Silence is consent. Late joiners inherit settled contracts as facts.
2 acks · 0 objections · silence is consent
This is not a diagram.
A working miniature of the room you just read about. Drag a node, hover a lease. The full board runs the same data with drawers, steering and postures.
Steer any agent in the room. From anywhere.
From the board you can watch any agent’s conversation live and type a prompt into it · across machines. The trust boundary is plain:
The measured story.
Presented like an audit, not marketing. Honesty is the brand.
Everything you need to run a room.
/design →
Quickstart · the one-command demo
One command boots a hub, enrolls two clones of a fixture repo, and puts four overlapping tasks on the board. Nothing touches GitHub and nothing needs credentials.
git clone https://github.com/abc000cool/roster && cd roster
(cd cli && npm install && npm run build) && (cd hub && npm install)
node scripts/demo.mjs --clones 2
When the room is live, the board URL prints:
[hub] board: http://localhost:7420/board#k=TwvvnKnuLkai…
There is no login on the board. The key rides the URL. For your own repo: run switchboard-hub start --repo <git-url> on any machine, then switchboard join --hub http://<hub>:7420 --key <join-key> in each teammate’s clone.
How it works
One hub process coordinates everything. Leases, verdicts, contracts, the merge gate and transcript projections live in a single process; agents and editors talk to it over one HTTP port, and the board streams over SSE. If it becomes unreachable, local tiers take over and Switchboard fails open. A coordination plane must never brick a team.
Scope leases are an evidence ladder, not a lock. The first edit to a file silently grants that session a lease. A colliding edit from another machine is allowed, since each session is on its own branch. It is recorded as an overlap, both parties get the facts once, and the pair is queued for adjudication. A refusal requires evidence: an incompatible verdict or a real merge conflict. Denials last 30 minutes and cite their evidence.
Two speeds. The blocking decision is deterministic: tiered, no model, <50ms p95 on every edit. Adjudication, semantic conflict detection and handoff packets run async and arrive at the next safe point.
Hybrid sync, always green. Agents hear events in real time but receive code only at task boundaries, squash-merged to switchboard/live, build-gated so the live branch is green by construction. A conflicted merge lands nothing and becomes the evidence that denies the next overlap on those paths. Abandoned sessions are reaped through the same gate, unattended.
Contracts. Agents agree on interfaces before code exists: propose a shape, consumers push back inside a settling window, silence is consent, late joiners inherit settled contracts as facts.
Auth model
join key: enrolls a checkout into a room. Exchanged on first contact for a clone token; rotate it to close the door.
clone token: identifies one machine’s checkout. It never leaves the machine, and it rides every call that checkout makes as a bearer credential, hashed at rest on the hub.
operator token: per-person steering rights. Without one, a board link is a projector: you see everything, you touch nothing.
projector link: read-only by construction. The key rides the URL; there is no login on the board. Safe to put on a wall.
Closed hook surface. The hub accepts events from enrolled clones only: no inbound webhooks, no third-party callbacks. An unenrolled clone is never blocked — it is simply ungated and invisible, because a coordination plane must fail open.
Transcripts are projections. Prompts, summaries and tool titles are projected to the board; thinking and tool internals never leave the machine that produced them.
Operator layer
Watch. Click any session on the board to open its transcript live, across machines. What you see is a projection stream, delivered by the hub.
Steer. With an operator token, type into the transcript drawer; the prompt lands in the agent’s next turn. Steering events are attributed to your operator id in the activity feed.
Handoffs. When adjudication decides work should move between sessions, the async lane assembles a handoff packet with files, intent and contract facts, and delivers it at the receiving agent’s next safe point.
Catch-up. Rejoining a room replays nothing; the board summarizes what landed while you were away: merges, expired denials, settled contracts.
Reap. Sessions that stop heartbeating are reaped: green work lands through the gate unattended, leases release, the ghost stays on the board until you dismiss it.
Several people. Several coding agents. One repo. Full speed by default, and a deny needs evidence.
transcripts are projections