Skip to content
/
Tier B A16 Cross-vendor router

Switchboard

switchboard · TentacleOpera/switchboard · ★ 209 · last commit 2026-05-26

Orchestrate heterogeneous AI agent teams via visual kanban drag-and-drop, routing tasks by complexity to the right model without writing prompts.

Best whenMulti-provider heterogeneity (routing by cost tier) is more valuable than single-provider optimization.
Skip ifSpending premium quota on context gathering (use free models for that), Manual prompt writing per task
vs seeds
agent-osfor its markdown-plan foundation, but Switchboard actively routes rather than passively scaffolding. The hierarchical to…
Primitive shape 21 total
Commands 8 Subagents 8 MCP tools 5
00

Summary

Switchboard — Summary

Switchboard is a VS Code extension that provides a visual kanban board to orchestrate teams of AI agents across multiple CLI tools and IDE agents without writing prompts. Plans are dragged between columns on an AUTOBAN (automated kanban), which triggers pre-configured prompts to the registered agent in that column using the VS Code terminal.sendText API. The extension supports eight named agent roles (Planner, Team Lead, Lead Coder, Coder, Intern, Reviewer, Acceptance Tester, Analyst), complexity-based routing, pair-programming splits, batch execution, and a Google Drive sync option for multi-machine/multi-developer sharing. No API keys are required — Switchboard sends messages to already-open CLI terminals. State is stored in a local database outside the git repo. Compared to seeds, Switchboard is most similar to agent-os in its markdown-scaffold approach to plans, but it replaces the passive markdown with an active visual routing layer; it also overlaps with claude-flow's hierarchical orchestration pattern but uses VS Code terminal injection rather than an MCP server, and it supports heterogeneous agent teams across Claude Code, Cursor, Windsurf, Copilot, and Gemini CLI — a level of cross-tool orchestration no seed framework attempts.

01

Overview

Switchboard — Overview

Origin

Switchboard was built by TentacleOpera (publisher: TurnZero) as a VS Code extension. Version 1.5.6 was the latest at analysis. The repository has 209 stars and 1 contributor. It has been actively pushed as recently as 2026-05-26.

Philosophy

From the README: "Drag and drop AI orchestration for VS Code — run your entire agent team without typing a single prompt."

"Switchboard is a different approach to AI orchestration. A visual kanban auto-triggers agents via drag and drop, no prompts required. This allows you to run entire agent teams while drinking a beer, since you only need one hand to code with Switchboard."

"There's nothing to install beyond the extension itself. If you already have your agents open, you're ready. No gateway, no runtime, no API keys, no config files. Just drag a card."

Key Design Opinions

  • Prompt-free orchestration: The human defines plans in plain text; Switchboard constructs and dispatches prompts automatically. The user's job is to drag cards, not type prompts.
  • Cross-provider heterogeneity: Deliberately routes different task types to different AI providers (Claude, Copilot, Gemini Flash, Windsurf) to maximize value across subscriptions.
  • No repo pollution: Plan state, routing rules, and archived plans live in a database (local or Google Drive), not in git commits.
  • Token efficiency: Pair programming mode and complexity routing are designed to minimize premium quota spend by routing appropriate work to cheap models.
  • Terminal injection, not API calls: Switchboard uses VS Code's terminal.sendText API to drive CLI agents, so it works with any tool that has a terminal interface — no special integration required.

Notable Quote on Token Efficiency

"Using the pair programming mode, Windsurf Opus reported token savings of 35% by offloading routine parts of the plans to Gemini CLI. Meanwhile, Gemini CLI deployed subagents to code 5 plans in parallel. This was all done by batch moving plan cards."

02

Architecture

Switchboard — Architecture

Distribution & Install

  • Distribution type: vscode-extension
  • Install: Search "Switchboard" in VS Code marketplace; publisher: TurnZero
  • Binary: switchboard-1.5.6.vsix (bundled in repo)
  • Version: 1.5.6
  • License: MIT
  • Required runtime: VS Code ≥ 1.90.0; no API keys; no additional npm packages

Directory Tree (repo)

switchboard/
├── src/
│   ├── extension.ts            # VS Code activation entry point
│   ├── lifecycle/              # Agent startup/shutdown management
│   ├── mcp-server/             # Embedded MCP server for agent coordination
│   ├── models/                 # Data models (plans, agents, roles)
│   ├── services/               # Core business logic (routing, dispatch)
│   └── webview/                # AUTOBAN kanban React webview
├── .switchboard/               # File-based coordination dir
│   ├── CLIENT_CONFIG.md
│   ├── SWITCHBOARD_PROTOCOL.md # Message schema specification
│   ├── plans/
│   ├── reviews/
│   └── sessions/
├── templates/                  # Plan templates
├── .agent, .cursor, .gemini, .kiro, .windsurf, .qwen  # Per-tool context dirs
└── AGENTS.md                   # Agent instructions

Key Technical Choices

  • VS Code extension (not a CLI tool) — activates on startup via onStartupFinished
  • Dual transport: MCP (stdio/HTTP-SSE) for MCP-capable agents; file-based fallback for others
  • Database: Local flat-file database (or Google Drive sync) outside the git repo
  • Terminal injection: VS Code terminal.sendText API sends prompts to running CLI terminals
  • Message format: JSON messages in .switchboard/inbox/<agent-name>/ directory
  • MCP server: Built-in MCP server at HTTP/SSE for agents that support MCP

Target AI Tools (Explicitly Supported)

  • Claude Code (CLI)
  • Windsurf
  • Cursor
  • GitHub Copilot CLI
  • Gemini CLI
  • Antigravity
  • Any MCP-capable agent via HTTP/SSE

Agent Role Definitions

Role Responsibility
Planner Premium model: writes plans, assigns complexity, recommends routing
Team Lead Optional cross-agent coordinator (off by default)
Lead Coder High-complexity implementation
Coder Low-complexity / boilerplate
Intern Lowest-cost repetitive tasks
Reviewer Grumpy Principal Engineer persona; scope creep detection
Acceptance Tester Validates against plan + Design Doc / PRD
Analyst Research and general questions
03

Components

Switchboard — Components

VS Code Commands (IDE Commands)

Command Purpose
/improve-plan Deep-plan a plan card directly into the database
/improve-plan (AUTOBAN toolbar) Improve all plans in column
Copy All Plans button Generate planning prompt from all board plans
Move Selected Route selected plans to next stage
Move All Route all column plans to next stage
Copy Prompt Selected Generate prompts for selected plans
Copy Prompt All Generate prompts for all plans
START AUTOBAN Begin automated timer-driven routing
Code Map Generate context-gathering prompt for free model
Report Send failed plans back to Lead Coder with feedback
Create Plan Add new plan to New column

MCP Server (Built-in)

Switchboard bundles an MCP server that exposes agent coordination tools:

  • delegate_task — Lead sends work to an agent
  • request_review — Agent requests code/plan review
  • submit_result — Agent returns completed work
  • status_update — Progress notification
  • execute — Direct terminal command injection

Switchboard Protocol

File-based message exchange in .switchboard/inbox/<agent-name>/msg_*.json:

  • id, action, sender, recipient, payload, replyTo, metadata, team, persona, createdAt

Agent Setup Items

  • Startup commands per role (e.g., copilot --allow-all-tools)
  • Complexity threshold slider
  • Team Lead lane on/off
  • Aggressive Pair Programming toggle
  • Per-column: agent count, timing interval, batch size
  • Project management integrations: ClickUp, Linear, Notion

Templates

  • Plan templates for common task types
  • Per-agent prompt templates (auto-constructed by Switchboard from plan metadata)

Routing Modes

  • CLI Triggers: terminal.sendText dispatch
  • Prompt mode: clipboard copy for IDE chat paste

Pair Programming Modes

Mode Lead Coder
CLI Parallel CLI terminal CLI terminal
Hybrid Clipboard → IDE chat CLI terminal
Full Clipboard Clipboard → IDE chat Notification → clipboard
05

Prompts

Switchboard — Prompts

Switchboard does not ship prompt files in the traditional sense. Instead, prompts are auto-constructed from plan metadata and injected via terminal.sendText. The .switchboard/SWITCHBOARD_PROTOCOL.md defines the agent communication schema.

Verbatim Excerpt 1 — Switchboard Protocol Message Schema

From .switchboard/SWITCHBOARD_PROTOCOL.md:

{
  "id": "msg_<timestamp>_<random>",
  "action": "delegate_task | request_review | submit_result | status_update | execute",
  "sender": "<agent-name>",
  "recipient": "<agent-name>",
  "payload": "<string — task description, review content, result summary, etc.>",
  "replyTo": "<optional — message ID being responded to>",
  "metadata": { "<optional key-value pairs>" },
  "team": "<optional — team ID if sent via send_team_message>",
  "persona": "<optional — injected persona text for role-based agents>",
  "createdAt": "<ISO 8601 timestamp>"
}

Technique: Structured message protocol with persona injection. The persona field allows Switchboard to inject role-specific instructions (e.g., "Grumpy Principal Engineer") into agent messages without requiring the agent to have that persona pre-loaded.

Verbatim Excerpt 2 — Routing Table Description (README)

Hit Copy All Plans to generate a planning prompt. Paste it into your 
Planner agent. It reads the board, enriches each plan, assigns a 
complexity score, and produces a routing table — every task gets an 
agent recommendation. You can see exactly what it decided before 
anything runs.

Hit the column controls to route in one click. The board constructs 
every prompt automatically and dispatches it to the right agent. No 
tokens spent on coordination.

Technique: The planning prompt is a meta-prompt that asks the Planner to both enrich plans AND produce a structured routing table. The routing table is then consumed by Switchboard to make dispatch decisions without further LLM calls.

Prompting Pattern Assessment

  • Role injection via persona field: The protocol supports injecting role descriptions per message, enabling dynamic persona assignment without modifying agent configuration.
  • Auto-constructed prompts: Users write goals; Switchboard constructs the full prompt including plan content, routing context, and instructions to spawn subagents.
  • No prompt files in repo: Prompt content is generated at runtime from plan state; no static prompt files are shipped.
  • Batch-with-subagent instruction: Every batch prompt includes an instruction to use native subagents, so individual tasks within a batch still get focused attention.
09

Uniqueness

Switchboard — Uniqueness & Positioning

Differs from Seeds

Switchboard is unlike any of the 11 seeds in its core mechanism: it uses VS Code's terminal.sendText API to dispatch prompts to already-running CLI agent terminals, requiring no API keys, no gateway, and no changes to the agents themselves. The closest seed is agent-os in its reliance on markdown plans as the human-authored artifact, but agent-os is a passive scaffold — Switchboard actively routes and dispatches. The orchestration topology (Planner → workers → Reviewer) resembles claude-flow's hierarchical pattern, but Switchboard introduces deliberate cross-provider heterogeneity (Claude, Copilot, Gemini, Windsurf) as a first-class feature, routing by complexity and subscription cost rather than by task semantics. No seed framework routes tasks across multiple AI providers at runtime. The MCP server bundled in Switchboard resembles the MCP-anchored approach of claude-flow, but Switchboard's MCP is a coordination layer rather than a tool-call server.

Positioning

Switchboard targets developers with multiple AI subscriptions who want to maximize value by routing simple tasks to cheap models and complex tasks to premium models — all without writing prompts. The "no typing" philosophy differentiates it from every other framework in the catalog, where the human at minimum types slash commands or filenames.

Observable Failure Modes

  • Terminal dependency: Switchboard requires the CLI agents to be running in VS Code terminals before routing. If a terminal crashes or the agent disconnects, routing silently fails.
  • VS Code lock-in: The entire interface is VS Code-specific. No CLI fallback, no headless mode.
  • No code-level validation: Switchboard has no hooks into CI, test runners, or linters. Quality depends entirely on the Reviewer and Acceptance Tester agents' behavior.
  • No git automation: Switchboard does not create branches, commits, or PRs; those are left to the individual agents.
  • State outside repo: Google Drive or local database state is not version-controlled; plan history can be lost if the database is deleted.

Explicit Antipatterns (from README philosophy)

  • Spending Claude Code quota on context gathering (offload to free models)
  • Single-provider agent teams (use heterogeneous teams to maximize value)
  • Manual prompt writing for each task (Switchboard constructs prompts automatically)
04

Workflow

Switchboard — Workflow

Phases

Phase Description Artifact
Setup Configure agent team, roles, startup commands Role assignments in extension settings
Plan creation User creates plans in AUTOBAN New column (plain text goals) Plan cards in database
Planning Click "Copy All Plans" → paste to Planner agent Enriched plans with complexity scores and routing table
Routing Click column controls or drag cards to dispatch Prompts sent to registered agent terminals
Implementation Lead Coder / Coder / Intern execute tasks; optionally with native subagents Code changes
Review Plans advance to Reviewer column; Reviewer checks against plan Review report
Acceptance Testing Acceptance Tester validates against plan and PRD Pass/fail result
Feedback loop "Report" button sends failures back to Lead Coder with comments Retried implementation
AUTOBAN automation Timer-driven automated routing without manual dragging Continuous pipeline

Approval Gates

Gate Type Description
Review Manual Human or Reviewer agent checks implementation against plan
Acceptance Test Automated (agent) Acceptance Tester validates against plan + PRD
Complexity routing confirmation Optional visual User sees routing table before executing; can override
Report feedback Manual Human writes feedback when acceptance fails

Spec Format

Plans are plain text (goal statements). No formal spec language. Plans can be enriched by the Planner agent with complexity scores and routing recommendations. PRD / Design Doc files can be attached to plan cards.

AUTOBAN Column Pipeline

New → Planning → Lead Coded / Coder Coded → Reviewing → Acceptance Testing → Done

Custom columns and roles can be added via the setup menu.

06

Memory Context

Switchboard — Memory & Context

State Storage

  • Plan database: Local flat-file database outside the git repo. Plans, routing rules, and archived plans persist here, not in git commits.
  • Google Drive sync: Optional sync for multi-machine and multi-developer access; the database lives on Google Drive rather than locally.
  • .switchboard/ directory: File-based coordination directory for agent messages during a session (inbox/, archive/, reviews/, sessions/, state.json).

Persistence Scope

  • Plans: Project-level; persist across sessions and machines (with Drive sync).
  • Session state: .switchboard/state.json (locked via proper-lockfile); shared across agents in the current session.
  • Message archive: .switchboard/archive/<agent-name>/ retains processed messages.

Memory Between Agent Invocations

Agents retain context through:

  1. Their own terminal session history (the CLI agents' built-in context)
  2. The plan card content (attached to each dispatched prompt)
  3. Code mapping results (attached to plan cards by the Code Map feature)
  4. Review comments (attached when "Report" is used)

There is no vector store or explicit LLM memory mechanism. Switchboard's memory model relies on attaching all relevant context to the prompt payload at dispatch time.

Context Compaction

Not applicable at the Switchboard level. Individual CLI agents handle their own context management. Switchboard's AUTOBAN timer spacing (configurable) implicitly manages rate limits rather than context.

Cross-Session Handoff

Plans persist in the database; a new session reads existing plan state from disk. Session messages in .switchboard/ are cleared between sessions.

07

Orchestration

Switchboard — Orchestration

Multi-Agent Support

Yes — explicitly designed for heterogeneous teams of 2–8+ agents across multiple AI providers and CLI tools.

Orchestration Pattern

Hierarchical (Planner → optional Team Lead → Lead Coder / Coder / Intern → Reviewer → Acceptance Tester). The Planner acts as a planning oracle; Switchboard acts as the routing middleware; downstream agents are execution workers. The Team Lead lane is optional and configurable.

Pair programming creates a parallel fan-out subpattern: Lead Coder handles complex tasks while Coder handles boilerplate simultaneously.

AUTOBAN automation adds a continuous loop pattern: plans cycle through columns automatically on a timer.

Isolation Mechanism

None at the filesystem level. Each agent runs in its own VS Code terminal with its own CLI session, providing implicit process isolation. No git worktrees or containers are created by Switchboard; individual CLI agents may use their own isolation (e.g., Claude Code can spawn worktrees independently).

Multi-Model Support

Yes, explicitly. The framework's core value proposition is routing tasks to appropriate models based on complexity:

  • High complexity → Lead Coder (premium model, e.g., Claude Opus, Windsurf)
  • Low complexity → Coder (cheap fast model, e.g., Gemini Flash)
  • Boilerplate → Intern
  • Optional threshold slider controls routing cutoff

Model assignment is user-configured per role slot; any CLI agent can be assigned to any role.

Execution Mode

Interactive loop — the human drives the AUTOBAN by dragging cards or pressing column controls. In AUTOBAN automation mode, it becomes a continuous timer-driven pipeline. Single cards can be routed one-shot.

Consensus Mechanism

None. Reviewer and Acceptance Tester roles provide quality gates but not consensus voting.

Prompt Chaining

Yes — plan content flows from Planner output into downstream agent prompts. Code Map results are attached to plans before dispatch. Review comments are attached when sending back for revision.

Cross-Tool Portability

High within the VS Code ecosystem. Supports Claude Code, Cursor, Windsurf, Copilot, Gemini CLI, Antigravity, and any MCP-capable agent.

08

Ui Cli Surface

Switchboard — UI & CLI Surface

VS Code Extension (Primary Interface)

Switchboard is distributed as a VS Code extension. The primary interface is a visual kanban webview (AUTOBAN) in the VS Code sidebar.

AUTOBAN Features

  • Drag-and-drop plan routing
  • Per-column agent assignment and role configuration
  • Complexity threshold slider
  • Batch plan dispatch controls (Move Selected, Move All, Copy Prompt)
  • Timer-based automation (START AUTOBAN)
  • Agent count per column
  • Pair programming mode toggle
  • Aggressive Pair Programming toggle
  • Code Map button
  • Report / send-back button

Local Web Dashboard

None. The kanban interface lives inside VS Code as a webview.

MCP Server (Built-in)

Switchboard bundles an MCP server accessible at:

  • Stdio: VS Code extension IPC (default for agents running inside VS Code)
  • HTTP/SSE: http://127.0.0.1:<port>/sse for external agents

The MCP server exposes delegate_task, request_review, submit_result, status_update, and execute tools.

Observability

  • AUTOBAN shows plan state, column assignments, and routing table results visually
  • Message archive in .switchboard/archive/ for post-session inspection
  • state.json provides current shared agent state

Dedicated CLI Binary

None. Switchboard has no CLI binary; it is VS Code-only.

IDE Integration

VS Code only. Per-tool context directories are present in the repo (.agent, .cursor, .gemini, .kiro, .windsurf, .qwen) to support agents running inside those IDEs when accessing the project.

NotebookLM Airlock

A documented feature for generating plans "at zero token cost" via NotebookLM — plans generated there can be imported into the AUTOBAN database.

Related frameworks

same archetype · same primary tool · same memory type

CodeMachine CLI ★ 2.5k
A16 Cross-vendor router

JavaScript-DSL workflow orchestration engine that captures repeatable AI coding agent workflows with tracks, condition groups,…

Codexia ★ 690
A16 Cross-vendor router

Tauri desktop app providing visual control plane, task scheduler, git worktree manager, and headless REST API for Codex CLI +…

Kagan ★ 88
A16 Cross-vendor router

Kanban TUI for AI coding agents with a structurally enforced human review gate (REVIEW → DONE cannot be automated) — one git…

oh-my-claudecode (Yeachan-Heo) ★ 35k
A16 Cross-vendor router

Zero-learning-curve teams-first multi-agent orchestration for Claude Code with autopilot (6-phase lifecycle), ralph (PRD-driven…

Paseo ★ 6.8k
A16 Cross-vendor router

Multi-provider AI coding agent orchestration daemon with cross-device access (phone/desktop/CLI) and git worktree isolation.

CCG Workflow ★ 5.4k
A16 Cross-vendor router

Routes Claude + Codex + Gemini to task-appropriate collaboration strategies (direct-fix through full-collaborate) with hook-based…