Agent Switchboard

Use Claude Code, Codex, Gemini, Antigravity, and VS Code together — without copy-pasting context between them.

Agent Switchboard is a local MCP bridge that lets your AI coding agents hand tasks to each other, review each other's work, run multi-round debates, and share compact project context — a local nervous system where the tools stay separate but coordinate through one local broker.

No API keys. No cloud broker. No extra billing. It uses the local CLIs, IDE bridge routes, and subscriptions you already have where possible.

⭐ If this saves your agent workflow, please star the repo so others can find it!

Why this exists

Modern AI coding workflows are fragmented. You might use Codex for implementation, Claude Code for review and reasoning, Gemini for planning or alternatives, and Antigravity / VS Code for workspace context — but normally they can't talk to each other, so you end up manually copying plans, files, errors, and context from one assistant to another. That's fine for small tasks; it gets messy fast on real projects. Agent Switchboard gives those agents a shared local coordination layer so they cooperate instead of working blind to each other.

Fast Version

• Ask one assistant to use another - from Codex, ask Claude Opus to audit; from Claude, ask Codex to implement; send Gemini/Antigravity-hosted models the planning work.
• See across chats - pull a compact snapshot of what another agent's session knows; Codex and Claude Code are read on demand from disk, no copy-paste.
• Run cross-model debate - Codex vs Claude for N rounds, then synthesize a verdict.
• Token compaction is built in - compressed handoffs, compact context packs, work memory, and retrievable originals instead of dumping entire transcripts.
• Keep it local - SQLite state under ~/.agent-broker; no private chat scraping, no cloud broker.
• Use subscriptions you already pay for - no required API keys or metered orchestration service.
• Know the truth - doctor reports which routes are full, partial, or app-only on your machine.

Everything user-facing — the agent-switchboard.exe binary, the command, and the MCP server key — is agent-switchboard. Internally, local state stays in ~/.agent-broker and the Python entrypoint is agent_broker_mcp.py.

Built for Antigravity and VS Code users. Antigravity is a VS Code fork, so the same bridge extension installs in both.

Honest scope: only Antigravity has a true programmatic in-app send and a structured reply back to the broker. Claude/Codex are reached through a CLI round-trip or an auto-opened inbox file - see Delivery, honestly. This is a power-user tool for people who already run these assistants; it drives logged-in subscription UIs, so read Terms & risk first.

Requirements

Two supported install paths — pick one:

• Self-contained agent-switchboard.exe (no Python needed). One file from the Releases page does everything: installs the MCP server into every assistant, installs the bridge extension (the VSIX is embedded), and runs the MCP server itself (agent-switchboard.exe serve). Has a built-in uninstall.
• Python 3.10+ (run from source). The broker is one dependency-free Python file; agents launch it as python agent_broker_mcp.py.

Other notes:

• Windows 10/11 for the installer, bridge auto-select, and shortcut patching (the broker itself is cross-platform; the installer/CDP layer is Windows-first today).
• Node.js on PATH is needed only for the CDP helpers (Antigravity model auto-select, Codex/Claude webview submit).
• Optional: pip install tiktoken for exact token accounting (a chars/4 estimate is used if it's absent; the exe bundles it).

Quick Start (Windows)

1. Close Antigravity and VS Code. The installer refuses to run while either IDE is open, so extensions and debug flags can't be left half-updated.

2. Install one of two ways:

   A — Self-contained exe (no Python): download agent-switchboard.exe from the Releases page and run it. Pick Install from the menu (or agent-switchboard.exe install).

   B — From source (Python 3.10+):

   powershell -NoProfile -ExecutionPolicy Bypass -File .\install-agent-broker.ps1
   

   Either way the installer detects which assistants you have (Codex, Claude Code, Antigravity, VS Code), registers the MCP server with each, installs the bridge extension (VSIX embedded in the exe; auto-built/located from source), and writes config. If Antigravity is installed, it then offers (default Yes) to enable automated in-app model selection — press Enter to accept (it patches the Antigravity launcher to open a local debug port) or decline to skip. Every config it edits is backed up first.

3. Open Antigravity / VS Code again so the Agent Switchboard Bridge extension activates.

4. Try it. In any registered assistant: "Use Agent Switchboard to ask Claude Opus to audit this function."

5. Check what actually works on your machine: run agent-switchboard.exe doctor (or python agent_broker_mcp.py bridge doctor). It's read-only and tells you, per assistant, whether a CLI/extension is present, which delivery route you'll get, and whether a headless debate can run — see Diagnostics: doctor.

Uninstall / rollback (both paths): run agent-switchboard.exe uninstall (or python setup.py uninstall), or pick Uninstall from the menu. It reverses MCP registration in all four hosts, removes the bridge extension, and removes the installed broker exe. Add --remove-data to also delete ~/.agent-broker. The broker uses whatever subscriptions your assistants are already logged into.

What It Does

How It Works

The broker is a dependency-free Python MCP server. Each assistant talks to it over stdio JSON-RPC; the broker keeps shared state in one local SQLite file (WAL mode, so multiple hosts can poll it concurrently) and routes work to the right place.

Routing priority:

1. Surface — Codex/Claude default to the headless CLI (reliable, model-switchable via -m, answer returned inline); say "in app" (or surface: extension) for the IDE chat panel, or "app" for a visible desktop-app handoff. Gemini and Antigravity-hosted models stay on in-app automation by default; only an explicit "gemini cli" uses the standalone Gemini CLI. Antigravity-hosted Claude/Gemini never use a CLI. If a CLI is absent, auto-routing degrades to the extension, then the app.
2. Model — vague requests ("ask Opus") resolve against a per-topic default; explicit requests ("claude opus") become the new default. Sending to Antigravity always requires naming a model (it hosts a separate, subscription-backed Claude/Gemini). Versioned names that the CLI can't pin (e.g. "opus 4.8") still resolve to the CLI's opus alias but now carry a note warning that the running version may differ.
3. Token budget — every routed task carries a task contract (implementation_plan, co_audit, debate, review, …) with a word budget, and a compressed context pack instead of raw history. If a caller inlines a bloated prompt (over a soft token limit), the broker stashes the full text as a retrievable context_ref and returns a prompt_notice nudging it to send a short instruction + ref next time — so token discipline is enforced by the system, not left to each agent.

See what another chat knows (active context snapshots)

Working in one assistant but need the current state another open chat is holding? Ask for a context snapshot — a COMPACT continuation state (objective, plan, touched files, checks, risks, next step), not a full transcript, and never silent scraping (it's opt-in and local).

• request_context_snapshot(project, topic, target_agent) asks the best available open surface for that compact state.
• Codex & Claude Code fast path (on disk): the broker reads the live session transcript on disk — Codex from ~/.codex, Claude Code from ~/.claude/projects — redacted + truncated and scoped to the session whose cwd matches the project (no cross-project leak), returning immediately with no agent cooperation or CDP needed. The two CLIs are symmetric.
• Antigravity fallback: when no live bridge snapshot is available, the broker can read local Antigravity task/log/activity files (~/.gemini/antigravity-ide/brain plus workspace/file history) and return a bounded, clearly low/medium-confidence continuation snapshot. This is not guaranteed to be the visible chat transcript, but it prevents dead-end "cannot find context" failures.
• Other surfaces: the request is queued for a capable bridge host (claim_context_snapshot_request / complete_context_snapshot_request, race-safe + idempotent, with a stale-claim reaper), or picked up from a .agent-broker/context-snapshots/ fallback file. If no live surface is heartbeating and no local fallback exists, the request reports no_live_surface (with guidance) instead of queuing forever with no claimer.
• Honest limit: a surface feeds the nerve system only if it's readable on disk (Codex/Claude Code), a live heartbeating bridge (Antigravity/VS Code), or it proactively records. A disconnected helper — e.g. the Claude desktop app (Electron + server-side history, not on disk) — can be registered to push context, but cannot be read on demand. doctor shows exactly which surfaces can contribute, so blind spots are visible, not surprising.
• Read it back with get_latest_context_snapshot — it also folds into get_context_pack ("Latest Context Snapshots") and get_topic_status, so the next model picks it up automatically. Live-host routing uses record_surface_heartbeat / list_live_surfaces.

This is the cross-chat "peek" layer: agents and IDEs can see what another agent's session currently knows and fetch it on request, without copy-pasting transcripts.

Delivery, honestly

There is a real difference between delivered (a file/prompt reached the surface), auto-opened (the bridge opened it for you), submitted (it was actually sent into a chat), and completed back to broker state (a model-tagged reply landed in the broker). Antigravity is still the only true structured in-app round-trip; queued Codex requests also get a broker-owned CLI worker when the Codex CLI is available.

Answer return-path: any surface without a native completion API closes the loop by calling respond_to_request(request_id, response) — the broker records the answer + timing on the request and refreshes a per-topic ledger.md (get_request_ledger). Codex inbox requests now also start a bounded CLI worker by default, so request_result returns an answer or a terminal error instead of staying delivered forever.

Model enforcement, honestly: the broker can only switch the answering model programmatically on Antigravity (CDP UI automation, best-effort) and the CLIs (--model/-m flag). It cannot drive the Codex- or Claude-extension model picker. So when a specific model is requested on those surfaces, the broker prepends a strict guard to the prompt — "you must be <model>; state your model; if you're not, STOP and ask the user to switch" — and the bridge pops a notification to select that model. This way a lesser/default model never silently answers in the requested model's place. A model named only in the prompt ("get Opus's opinion") is detected conservatively and treated as the requested model for that one request (it does not overwrite the topic default).

Model + effort on the CLIs: model and reasoning effort are separate inputs, never folded together. Pass effort (minimal|low|medium|high|xhigh|max; "extra high" -> xhigh, "ultra"/"max" -> family top) and the broker sets it as its own CLI flag (Codex -c model_reasoning_effort=, Claude --effort) - it is never appended to the model name. A bare family request ("codex", "claude") defaults to the flagship model at the highest available effort (Codex gpt-5.6-sol/max, Claude opus/max); a specific model is honored verbatim ("sonnet 4.6 for implementation", "gpt-5.6-luna for cheap reading"). Effort phrases embedded in a model request ("5.6 sol extra high") are split off before matching, so they resolve to model gpt-5.6-sol + effort xhigh rather than an invalid model string.

The broker is target-driven when a target is named. If a Codex/Claude caller leaves the target completely empty, Switchboard uses the caller only as a fallback: Codex defaults to Claude, and Claude defaults to Codex. A named target or prompt phrase like "consult with Claude" still wins.

Diagnostics: doctor

Because "what works" depends on what you have installed, the broker ships a read-only doctor that probes this machine and tells you the truth — no state is changed.

agent-switchboard.exe doctor          # rendered report
agent-switchboard.exe doctor --json   # machine-readable
# from source:  python agent_broker_mcp.py bridge doctor

For each assistant it reports: whether the CLI is found (and a live --version smoke test), whether the extension is installed, the CDP port, the delivery route you'll actually get, the reply path, and whether a headless debate can run. It also prints a nerve-system view — which surfaces can feed request_context_snapshot (on-disk fast-path vs live bridge vs push-only), so a blind spot like a disconnected desktop app is visible. It flags broker/bridge version drift and prints actionable next steps.

What each install combination gets you (this is what doctor checks):

Headless debate (running both sides automatically) needs both the Codex and Claude CLIs present — doctor reports headless autonomous debate runnable: YES/no before you try. Extension-only setups can still get a one-shot second opinion, just not an autonomous multi-round run.

Changelog

v1.0.21 (limits are advisory — stop force-shrinking data between sessions)

• Inline consult responses: default 5k → 20k chars, hard ceiling 40k → 200k (AGENT_BROKER_CONSULT_RESPONSE_CHARS / _MAX). Full responses were always preserved (history + request row + response_ref), but the small inline cap force-shrank what the calling session actually saw.
• Truncation no longer mangles structure. The old path collapsed all newlines/indentation (destroying code blocks and diffs). The rare over-ceiling cut is now a clean tail-cut at a line boundary with an explicit [... truncated inline; FULL response preserved — see response_ref] marker.
• Word budgets are now explicitly ADVISORY in the task contract, ground-rules file, and the prompt-size notice: aim lean, avoid redundant content (re-pasted files the receiver can read itself), but never omit unique data needed for a correct/complete answer. The prompt notice now states the prompt was delivered in full.
• Audited the full transfer path: prompts (MCP → DB → stdin → CLI) and responses (CLI pipe → DB → request_result) move untruncated; only display excerpts (history, event log) are shortened.

v1.0.20 (no stray Claude tabs — worker requests skip the UI inbox)

• Worker-handled Claude requests no longer open a new Claude tab. v1.0.19 wrote the inbox .md and started the CLI worker, so the bridge also delivered the prompt into the IDE — a stray tab popped up while the worker answered headless. Inbox files are now written only when no CLI worker took the request (UI fallback path), and the worker deletes any leftover inbox copies when it finalizes (covers rows queued by older servers).

v1.0.19 (Claude/Fable requests get the CLI worker too)

• Queued Claude consults no longer sit "queued" forever. A Claude inbox request (e.g. Opus consulting Fable) used to depend entirely on an interactive session or the bridge picking the inbox file up — in a headless environment nothing ever did. Queueing now also starts a detached Claude CLI worker (claude -p --model fable/opus/sonnet/haiku --effort …, same machinery as the Codex worker: atomic claim, 1800s cap, rowcount-gated side effects, no console window) that records the answer; collect it with request_result(request_id, wait_seconds=180). The inbox file stays as the UI fallback. Disable via AGENT_BROKER_CLAUDE_QUEUE_AUTORUN=0.
• Targets that aren't CLI-runnable (e.g. Antigravity panel models) keep the UI delivery path, and now expire with a clear error after ~35 min instead of hanging forever; stale-expiry covers claude_requests like it covers codex_requests.
• Schema: claude_requests gained effort, cli_model, worker_pid, worker_started_at, worker_completed_at (auto-migrated).

v1.0.18 (max-effort headroom + honest wait expectations)

• Worker cap raised 900s → 1800s. A max-effort Sol consult on a real design prompt commonly runs 5-15 minutes (live-measured: 8m21s); the old cap risked killing legitimate long runs. Override via AGENT_BROKER_CODEX_ASYNC_TIMEOUT_SECONDS.
• Pending/running responses now state the real ETA. The pending payload carries typical_wait: "5-15 minutes at max/xhigh effort" and retry_after_seconds: 120 (was a hammer-inducing 20), and request_result reports elapsed_seconds plus a "this is normal, not a hang" note for max/xhigh — so callers stop reading a 8-minute run as stuck.

v1.0.17 (consult is always Sol/max — no silent downgrade)

• Removed the prompt-keyword "cheap read" guesser. It was silently routing real consults to gpt-5.6-luna at low effort whenever the prompt mentioned reading/lines/deleting — producing hedged, untrustworthy answers. Luna now runs only when the caller explicitly sets model_policy='cheap_read' or names a Luna model.
• A serious consult on Sol is forced to max. Even if the caller passes high/medium, a consult/plan/audit/review/debate is clamped up to max (unless it explicitly opted into a cheaper tier). Safe now that max routes async instead of hanging — so the earlier hang fix no longer costs you effort.

v1.0.16 (no more stray cmd windows)

• Consults no longer pop an empty cmd.exe window on Windows. The detached async worker runs without a console of its own, so the Codex/Claude CLI (and git/powershell helpers) it spawned were getting a fresh console window that lingered on screen. Every child process now spawns with CREATE_NO_WINDOW, so all consultation work happens silently in the background.

v1.0.15 (highest-effort default + effort-based async routing)

• Consults/plans default to gpt-5.6-sol at max again (v1.0.14 had dropped this to high). Quality is the default; latency is handled by routing, not by lowering effort.
• max/xhigh consults route async up front. Instead of blocking the 240s sync window and then reporting pending, an effort that doesn't fit the window returns a pending request_id immediately while the detached worker finishes it — collect with request_result(request_id, wait_seconds=180). Efforts that fit (high/medium/low) still return inline.
• Reading/labour stays on Luna. model_policy='cheap_read' (and cheap/reader-shaped requests) run gpt-5.6-luna at low and return inline.
• Defaults only — the caller always overrides. An explicit effort, target_model, or model_policy wins: request Luna for a consult, or Sol/max for anything, as the task needs.

v1.0.14 (Codex consult no longer hangs / times out)

• Direct consult_codex no longer times out and discards the work. A consult now runs through the same ledger+worker path as queued requests: it returns the answer inline when it finishes inside the sync window, otherwise it returns a status: "pending" payload with a request_id — the detached worker keeps running to its own cap and records the answer, so nothing is lost. Collect a pending answer with request_result(request_id, wait_seconds=120).
• Consults default to high effort, not max. At max, gpt-5.6-sol routinely overran the 240s sync window and the timeout threw the work away. high finishes inline for typical consults; the sync path no longer clamps serious consults up to max (the async routing paths still do). Pass effort: "max" explicitly when you want it — that request just returns a pending id.
• request_result / request_status gained wait_seconds long-poll. One call blocks (bounded to the MCP window) until the request reaches a terminal state, the reliable way for a turn-based caller to collect a pending consult.
• Worker hardening. Atomic single-writer claim (no duplicate workers on a simultaneous start); post-completion history/events are skipped when a worker loses the finalize race; lone UTF-16 surrogates in CLI output are scrubbed before the DB write (previously crashed store_consultation after a successful consult, discarding the answer).

v1.0.13 (Codex inbox async worker)

• Claude -> Codex inbox requests no longer stay delivered forever. Queued Codex requests now start a bounded headless Codex CLI worker that writes the answer/error back to the same request row.
• Old stuck Codex inbox requests now fail cleanly when polled. request_status / request_result turns stale pre-fix Codex rows into terminal errors with a requeue note.
• Async Codex requests preserve model policy. Task kind, token budget, target model, and effort are stored on the queued request, so serious Sol consults still run at max.

v1.0.12 (Codex consult effort guard)

• Serious Codex Sol consults no longer silently run at medium. Accidental lower efforts on gpt-5.6-sol consult/audit/review/debate routes are upgraded to max.
• Deliberate downshifts are still allowed. Use model_policy: "balanced", "efficient", or "lower_effort" when medium/lower effort is intentionally enough, or model_policy: "cheap_read" for Luna reader/sample-prep work.

v1.0.11 (Codex 5.6 routing guide)

• Codex defaults now target GPT-5.6 Sol at max reasoning. Bare codex/gpt consults, audits, reviews, debates, and co-op routes resolve to gpt-5.6-sol with max effort.
• Cheap reader/sample-prep requests now downshift automatically. Explicit cheap/fast reading, extraction, summarizing, drafting, or sample-prep requests can use model_policy: "cheap_read" and resolve to gpt-5.6-luna with low effort.
• Agents can ask the broker which model policy to use. New get_model_routing_guide returns the policy, examples, and available model catalog so Claude/Codex do not have to rediscover the rules every session.

v1.0.10 (consultation response redaction fix)

• Successful local consultation answers are no longer line-redacted before return or storage. Long Fable/Claude/Codex/Gemini responses now keep security-audit wording intact in both the inline excerpt and retrieve_shared_context(response_ref, query).
• Generic shared context redaction remains enabled by default. User-provided context, prompts, logs, and error responses still use the existing safety redaction path.
• Retrieved shared context now flags stored redaction placeholders. Older refs that already contain [redacted possible secret line] report contains_redaction_placeholders so callers know those lines were removed before storage.

v1.0.9 (Fable backend routing fix)

• Fable max no longer gets caught by the Opus async-inbox rule. The automatic async queue is now limited to opus at max effort; fable, sonnet, and other Claude aliases stay on the direct Claude CLI backend unless async is explicitly requested.
• route_agent_task now honors the requested Claude effort. A routed request with effort: low now resolves and runs as low instead of silently falling back to Claude's max-effort default.
• Stale Fable inbox requests can be safely cancelled. The failed queued Fable requests from the regression are terminal once cancelled and will not be re-delivered by the bridge.

v1.0.8 (async Opus Max consults)

• Heavy Codex -> Claude Opus/max consults no longer block inside the MCP timeout. Reviews, audits, debates, bug hunts, implementations, and other large max-effort Claude requests from Codex now queue through the Claude inbox and return a request id immediately.
• Opus/max quality is preserved instead of downgraded. The queued Claude request carries a strict model guard plus an explicit effort guard, so the receiver is told to use Claude Opus at max effort or report a mismatch instead of silently answering with a lesser/default model.
• Codex can track the queued Claude answer. queue_claude_request, get_claude_requests, request_status, and request_result are now exposed as MCP tools, so a caller can queue a long Opus pass, keep working, then retrieve the recorded answer.
• Claude inbox prompts now include the return path in the injected body. Claude sees the exact respond_to_request(...) instruction, plus the .agent-broker/claude-responses/<request-id>.md fallback, after the bridge strips the metadata header.

v1.0.7 (direct consult timeout hardening)

• Direct Claude/Codex consults now finish before Codex's MCP tool-call timeout. Synchronous CLI consults are capped below the client timeout, so Codex gets a controlled broker response instead of a red timed out awaiting tools/call failure.
• Codex -> Claude CLI consults are isolated from Claude extension state. Switchboard starts Claude consults with safe mode, an empty MCP config, no Chrome bridge, and no session persistence so a Claude extension task using Switchboard does not bleed into a Codex extension consult.
• Claude consults now use stream-json parsing. If Claude starts answering but does not finish before the safe timeout, the broker can return any partial answer it received instead of losing everything.
• Tool descriptions now warn that direct consults are bounded. Full-site reviews should be split into batches or routed asynchronously; a single synchronous MCP tool call is not a safe place for a many-minute Opus pass.

v1.0.6 (Codex/Claude peer-consult fallback)

• Codex can now ask for a peer consult without naming every routing field. If a Codex-origin Switchboard call leaves target_agent and target_model empty, the broker now defaults to Claude Code CLI with the flagship Claude model (opus, max effort) instead of falling into Antigravity model selection.
• Claude gets the symmetric fallback. Ambiguous Claude-origin consult/co-op/debate requests now default to Codex CLI with the flagship Codex model (gpt-5.5, xhigh effort).
• Prompt wording still wins. Natural phrases such as "consult with Claude" or "ask Codex for a second opinion" are detected before the peer fallback, and explicit structured targets continue to take priority.

v1.0.5 (Antigravity local context + Claude tool permissions)

• Antigravity context pickup no longer dead-ends when no live bridge answers. request_context_snapshot(target_agent="antigravity") now falls back to bounded local Antigravity task/log/activity state (~/.gemini/antigravity-ide/brain), workspace state, file history, and recent project file mtimes. It clearly labels the result as low/medium-confidence instead of pretending it is a guaranteed visible-chat transcript.
• Claude's default MCP catalog now includes the tools Switchboard asks it to use. The lite profile exposes Codex queue/status, work-memory recording, context-event recording, and request-ledger tools, so Claude no longer gets instructions to call hidden tools such as record_work_memory.
• Docs now describe the real Antigravity fallback and Claude tool profile. README context-snapshot and tool-profile sections now match the shipped behavior.

v1.0.4 (Antigravity bridge claim isolation)

• Antigravity bridge claims are now workspace-scoped and fresh-only by default. The bridge passes its current workspace root when claiming queued Antigravity work, and ignores queued work older than 10 minutes unless configured otherwise. This prevents an unrelated Antigravity window/chat from waking up for stale or cross-project broker tasks.
• Context snapshot claims use the same isolation. Live bridge hosts now claim snapshot requests only for the active workspace and within the freshness window, so snapshot polling cannot route another project’s request into the visible Antigravity panel.
• Antigravity broker handoffs are one-shot by default. The bridge prompt now tells the in-app agent not to create scheduled tasks, background timers, wait loops, or delayed follow-up chat turns after a broker request is delivered. If a deploy/test/tool is still pending, the agent should report current status, complete the broker request, and stop.
• Bridge settings added: claimCurrentWorkspaceOnly, antigravityClaimMaxAgeMs, snapshotClaimMaxAgeMs, and preventAntigravityBackgroundTimers. Bridge extension version is now 1.0.1.

v1.0.3 (Claude/MCP context budget reduction)

• Claude gets a lite MCP catalog by default. When the MCP client identifies as Claude, tools/list now returns 18 compact user-facing tools instead of the full bridge/internal catalog. It includes Codex routing, request return, and work-memory recording so broker instructions never ask Claude to call hidden tools. Set AGENT_BROKER_TOOL_PROFILE=full or mcp_tool_profile: "full" if a client needs every internal bridge tool.
• Tool results are summary-first. MCP JSON results are compact by default, get_consultation_history now returns bounded summaries unless include_raw=true, and long consult responses return an excerpt plus response_ref for explicit retrieval.
• Smaller default context reads. Default context packs are 2.4k tokens, work memory is 5 entries / ~2.6k chars, and snapshot fast paths read 4 turns / ~300 tokens unless a caller asks for more.

v1.0.2 (straightforward CLI model + reasoning-effort selection; smallest-sufficient build rung)

• Pick the model and reasoning effort the obvious way. consult_codex / consult_claude / route_agent_task now take a first-class effort field (minimal|low|medium|high|xhigh, plus phrases — "extra high" → xhigh, "ultra"/"max" → family top) that is passed to the CLI as its own flag (Codex -c model_reasoning_effort=, Claude --effort) and never smuggled into the model name. A bare family request — "codex", "claude" — now resolves to the flagship model at the highest available effort (Codex gpt-5.5/xhigh, Claude opus/max) instead of stalling on a model-selection prompt; a specific model is honored verbatim ("sonnet 4.6 for implementation", "gpt-5.4-mini"). Effort phrases are split out of the model text before matching, so a request like "5.5 extra high" resolves cleanly to model gpt-5.5 + effort xhigh — fixing a class of failures where the effort phrase produced an invalid --model "gpt-5.5-codex xhigh" (rejected by Codex). Per-request auto-pinning of a topic default is now opt-in (remember_model). New shared helper resolve_cli_model_and_effort(); Fable added to the Claude catalog. (Tagged v1.0.1 in source; first shipped as a binary in v1.0.2.)
• Smallest-sufficient-implementation rung in the build contracts. The implementation and implementation_plan task contracts now tell the receiving agent to prefer the standard library / a native platform feature / an already-installed dependency over new code or new dependencies — explicitly without dropping required validation, error handling, security checks, or tests, and without disputing an approved plan (stop and report instead). Scoped to code-writing task kinds only; consult/co_audit/debate/review are unchanged, so second-opinion reasoning quality is untouched.
• Installer: more reliable Claude desktop detection. Recognizes the Microsoft Store / MSIX "Cowork" build (registered AppX package) in addition to the %APPDATA%/Claude data dir and the legacy standalone installer, so Store users aren't false-negatived.

v1.0.0 (diagnostics + Claude reply path + CLI-default routing + debate + Claude Code nerve-system)

• Claude Code joins the nerve system (on-disk fast path). request_context_snapshot now reads live Claude Code sessions on disk (~/.claude/projects, scoped to the session whose cwd matches the project) and completes immediately — symmetric with the existing Codex ~/.codex reader, so the most common "recent chat" surface is finally peekable without any agent cooperation. When no surface is heartbeating it returns no_live_surface (with guidance) instead of queuing forever; doctor gained a nerve-system report of which surfaces can contribute (on-disk vs live bridge vs push-only); and the installer now also registers the Claude desktop app (push-only — it stores chat in Electron/server-side and can't be read on disk, surfaced honestly in doctor). Installer hardening: Antigravity debug-port helper scripts are copied to a durable ~/.agent-broker path (the frozen-exe build previously baked a PyInstaller temp path into the launcher shortcut, breaking Antigravity launch after install), uninstall restores the patched launcher shortcuts so the opt-in is fully reversible, and the setup menu leads with Install (Status moved last).
• Headless CLI is now the default route for Codex/Claude. route_agent_task sends Codex/Claude work to the headless CLI by default (reliable, model-switchable via -m, answer returned inline). Say "in app" / surface=extension for the in-app IDE chat panel, or surface=app for a visible desktop-app handoff — both honored. Exceptions: Gemini defaults to Antigravity in-app automation unless you explicitly request surface=cli; and Antigravity-hosted models (e.g. Antigravity's Opus/Gemini) always use Antigravity automation, never a CLI. If the CLI is missing, auto-routing degrades to the in-app extension, then the app handoff.
• Antigravity automation is a true round-trip (verified). From any driver (e.g. the Claude app) you can route to a named Antigravity model — the bridge auto-selects that model (switching away from whatever was active) over CDP, sends the prompt into the live Antigravity agent panel, and the structured reply returns to the broker (complete_antigravity_request). Confirmed working end-to-end: "send to Antigravity Gemini 3.5 (High) and reply" auto-switched the model and returned the answer. This remains the only surface with a fully programmatic in-app send and structured reply.
• doctor — read-only capability report. agent-switchboard.exe doctor (or bridge doctor [--json]) probes this machine per assistant: CLI present + live --version smoke test, extension installed, CDP port, the delivery route you'll actually get, the reply path, and whether a headless debate can run. Flags broker/bridge version drift and prints next steps. No new MCP tool (CLI-only — keeps the 36-tool context budget unchanged). Also probes for a CLI binary bundled inside an installed extension as a detected-and-smoke-tested fallback, never an assumed one.
• Claude-extension replies are now first-class. Added a durable claude_requests table (mirrors codex_requests): queue_claude_request records a row, respond_to_request and ledger.md now recognize Claude requests, and a new bridge claude-responses [project] verb ingests answer files written under .agent-broker/claude-responses/ (idempotent; archives to processed/). Previously a Claude-extension reply had no row to attach to. Still no MCP tool added (36 unchanged).
• Internal request-lifecycle adapter. One canonical state map + `is_termina