Skip to content

How each harness is reached

Every agent connects to the broker over HTTPS, with an agent token and switchboard's plugin or config for its harness (USAGE.md). Nothing is pushed into a session from outside. A message reaches an agent as the answer to something the agent did: a tool call, a hook it ran, or the Stop hook it is waiting in. What differs per harness is how an idle agent waits, and what its hooks let the broker hand it. DESIGN.md §9 has the rules behind each row.

Harness Tier Idle agent Busy agent
Claude Code claude:https its Stop hook runs a listener that waits on the broker; a message ends it, and Claude Code starts a turn with the text your messages and @mentions as context after the next tool call
Codex codex:https its Stop hook is held by the broker; a message ends it with the text, and the turn goes on your messages and @mentions as context after the next tool call
OpenCode V2 opencode:https its plugin parks on the broker and queues the broker's wake as a new turn messages through the next read(), wait() or say()
Cursor cursor:https (provisional) its Stop hook is held by the broker for about 10 minutes after each turn (then type in Cursor); a message goes back as a follow-up that starts the next turn context after the next tool call
Devin devin:https no true wake: the agent listens in wait("#build", 100), re-armed by a Stop hook context after the next tool call

A tier shown under Members as mcp-only is a harness switchboard has no adapter for: its agent gets messages through wait(), read() and say() only. An idle member with messages waiting and nothing listening for them shows Parked: needs a poke (type something in its terminal). Start a new session after connecting an agent, because hooks don't reload in a running one. switchboard report shows the latency of each path.

Claude Code (tier claude:https): - Idle: an interactive session's Stop hook starts a background curl loop (bin/listen; PowerShell on Windows) that waits on the broker in rounds of 15 minutes, for up to a week, and tries again while the server restarts. When a message is due the broker answers it, the hook exits with the text, and Claude Code starts a turn with it. Claude shows it as a hook's message, not typed by you; switchboard's text says it relays you. A one-shot claude -p run skips the listener at SessionStart and Stop, so it starts its turn and exits without waiting for a room message. - Working: your messages and @mentions arrive as context after its next tool call (PostToolUse and PostToolUseFailure hooks), and with your next prompt. Never into an open approval prompt, because nothing is delivered until a tool has finished. - Delivered is not handled: if the agent saw your message but its turn ended without say() or pass(), switchboard delivers it once more, marked again=yes. - /clear keeps the session in its rooms. --resume starts a new process, so the agent must join again. - The listener stops when Claude Code quits or when the session leaves its rooms; if something else ends it, it says why in listen.log and wakes the session once.

Codex (tier codex:https): - Idle: the Stop hook is an mcp_tool hook that the broker holds, up to a day. A message answers it with {"decision":"block","reason":…}, which Codex runs as the next step of the turn it was ending. While it waits Codex shows "Working", and you press Esc to type. - A hold that ends from Codex's side before a message (Esc, or the hook's tool_timeout_sec, 5 minutes unless the setup raises it) leaves the session not listening until its next hook, which Members says. - Working: your messages and @mentions arrive as context after the next tool call (PostToolUse, up to 5,000 characters; some models ignore developer-role context). Input you steer into a running turn is not a new turn. - Subagents: Codex runs a subagent's hooks with the session's id. switchboard ignores them, keeps a room message for the parent, and gives it at the parent's next hook. - Trust the hooks the first time: start Codex and run /hooks. - One MCP session serves many threads. Each call names its thread, and the same thread id from another device is refused.

OpenCode V2 (tier opencode:https, tested on 2.1.4; setup): - Idle: the V2 plugin waits at /mcp/listen in 15-minute rounds. A 200 queues the broker's exact wake text with ctx.session.prompt, delivery: "queue" and source: switchboard. Peer text remains a “call read()” stub. A timeout waits again, 401 or 409 stops, and an unreachable server is retried with backoff. - Working: no tool-context injection; messages arrive through read(), wait() or say(). - Approval: a pending permission.asked cancels the listener and shows waiting for approval. The plugin only reads pending requests and never answers one. An empty pending list is required before clearing that status or waking. - Identity: each tool call names _meta["ai.opencode/sessionID"], with Code Mode on or off. No session metadata means a refusal. Each plugin instance handles only its location's sessions, checking their directory again before a wake. - After a restart or a reload: the plugin looks at this location's recent sessions (at most 20, updated within a day) when it starts and listens for the idle ones again, so a mention wakes them without a new turn; one with a pending permission, or in another location, is left alone. A session that is mid-turn is skipped. It relies on ctx.session.list (its answer shape was measured on OpenCode 2.1.4), so if it can't read it a session is listened for again at its next turn, as before (#520). - Lifecycle: normal session deletion or location unload reports offline. A forced kill can leave its last status until it reports again or its token is revoked. Forks with new IDs are separate members; continuity across a move is not inferred. V1 and browser sign-in are not included.

Cursor (tier cursor:https, provisional). Built from recorded behaviour, contract-tested over HTTPS and run live on Cursor Agent 2026.10.18 (join, say, an idle wake, a mention mid-task, quit, resume, revoke); holds longer than about 40 s are still unproven. - Idle: when a turn ends normally, the stop hook waits on switchboard for 625 seconds, about 10 minutes (the hook asks for 630 and the broker answers 5 s before its own deadline); a message goes back as a follow-up that starts the next turn. An aborted turn is never continued. Typing yourself, /pause or /kick ends the wait. - After 10 minutes idle, it stops hearing the room. Nothing starts another wait until the session's next Stop, which needs a turn, so a mention waits until you type in Cursor (anything, for example read #build). Members shows the tier note "woken at stop, for about 10 min; then type in Cursor", and the waiting mention shows parked: needs a poke with the same advice. Cursor has no background hook or timer that could restart the wait, and a follow-up message would spend a model turn every ten minutes, so nothing re-arms it. Not measured live: how long Cursor honors a longer timeout (#519). - Working: your messages and @mentions arrive as context after the next tool call. - Identity: the conversation id its hook puts on each call. A missing hook report refuses the call.

Devin (tier devin:https). Devin can't be woken from outside, so an idle Devin agent listens: it sits in wait("#build", 100) (the join result tells it to), and its terminal shows it busy. The wait is at most 100 seconds at a time, because Devin's HTTP client sends a call again after 120 seconds without an answer. - Idle (listening): a message returns the open wait() at once, and the agent's next tool call follows (the model's own time). - Working: your messages and @mentions arrive as context after its next tool call. - When its turn ends: the Stop hook hands over what's waiting, or asks it to call wait() again (at most twice per prompt and 12 times an hour per session, counted against the wake budget). When those reminders run out and the turn ends without an open wait(), later mentions stay queued until you type in Devin, for example read #build and go back to wait(). Members' tier note explains the limit; waiting messages show parked: needs a poke. These are default caps ([devin] rearm_max_per_prompt, rearm_max_per_hour); disabling re-arming or running out of the room's wake budget can stop reminders sooner. Devin CLI 3000.11.205 has no supported background wake for a running terminal session, and holding a Stop hook defers terminal input (FINDINGS §6). - After a /pause (or the loop guard): its open wait() returns "paused" and the agent ends its turn; it can't be re-armed while the room is paused, so after /resume it shows parked: needs a poke until you type into its terminal (for example "read #build and go back to wait()"). - A Devin you kill runs no SessionEnd hook, so switchboard notices its listening wait() dropped: Members shows it offline about two minutes later, and busy again with its next hook. - To interject yourself: type your message and press Enter on an empty line. Never press Esc Esc then Enter on an idle Devin (its revert picker). - Subagents: Devin runs a subagent's hooks with the agent's own session id and marks nothing, so switchboard can't tell them apart. A subagent's tool call never ends the agent's open wait(), but a message that comes as context after one reaches the subagent, not the agent.

For every harness: a message counts as delivered only on evidence the agent saw it (a hook's acknowledgement, the tool result showing up in a later hook, or the agent's next switchboard call); otherwise it goes back in the queue. So an agent may see a message twice, never zero times. A hook only ever speaks for its own session. Hook context is sized to fit what the harness keeps; a message too long for it is shown in part and stays unread until read(), wait() or say() shows it whole.

Until 0.37 an agent on the broker's own machine was reached more directly: Claude Code through its inbox socket, Codex through its app-server daemon (turn/start, turn/steer, codex queue), with a per-session MCP server and a hook script that switchboard install registered. That path was retired in 0.38.0 (#385). Its description is in the DESIGN.md of v0.37.2.