Switchboard

An open-source command center for coding agents, terminals, files, and git worktrees.

Product site | Latest release

welcome.mp4

Switchboard keeps coding agents, real terminals, files, git worktrees, and remote machines in one desktop workspace. Send terminal output, file ranges, and chat messages to an agent without leaving the project.

Today, Switchboard supports Claude Code, Codex, and OpenCode. Cursor and additional providers are planned. The provider layer is designed to grow, and contributions are welcome.

Status: pre-1.0. macOS Apple Silicon and Windows x64 builds are published through GitHub Releases with auto-update. Builds are unsigned. On macOS, Gatekeeper blocks the first launch - run xattr -d com.apple.quarantine /Applications/Switchboard.app after install, or right-click the app and choose Open. See Install.

Why Switchboard?

In a typical project, agent context is fragmented across a chat window, terminal tabs, logs, and an editor. The agent does not automatically see the error from the running service or the branch you are testing.

Switchboard connects those surfaces. Select terminal output, a file range, or a chat message and send it to the active agent with Cmd+L. Run parallel work in isolated git worktrees. Review the diff an agent actually produced. Keep conversations, terminals, files, and machines attached to the project rather than scattered across applications.

What you can do today

Work with the agents you already use

• Run Claude Code, Codex, or OpenCode in dedicated chat panes.
• Start two agent chats side by side to compare approaches or delegate parallel work. Use Open beside in a chat header or session menu (Cmd+Shift+\\), then Copy prompt → other to give both agents independently editable drafts.
• Choose permission modes per chat: plan, sandbox, accept edits, or full access. Plan mode is enforced by Switchboard, not just requested from the provider.
• Resume Claude Code sessions, and search Claude Code and Codex history from the project sidebar.
• Use skills and slash commands exposed by the active provider.

Give agents useful context

• Send selected terminal output, file ranges, or prior chat messages into a chat with Cmd+L.
• Paste or drop screenshots directly into a supported agent chat.
• Use Cmd+K for a focused prompt without leaving the current workspace.
• Open files referenced in a chat directly in the embedded VS Code workbench.

Keep parallel work under control

• Run real shells in a tmux-style tree of resizable terminal panes.
• Create a kanban card that launches an agent in its own git worktree.
• Fork a conversation from any message, optionally into an isolated worktree.
• Review per-file and per-hunk diffs from a git checkpoint after each agent turn.
• Save named terminal templates in .switchboard/workspace.yaml and apply them to new chats.

Work across machines

• Connect to a Linux machine through your existing SSH configuration.
• Run Claude Code, terminals, git, and file access on that machine while keeping the Switchboard interface on your laptop. Remote Codex and OpenCode support is not available yet.
• Reconnect to remote chats and browse recent remote projects while offline.

Providers

Provider	Status	Notes
Claude Code	Supported	Agent SDK integration, sessions, permissions, skills, images, and remote machines
Codex	Supported	codex app-server integration, sessions, permissions, skills, and images
OpenCode	Supported	Agent Client Protocol integration, dynamic models, skills, and images
Cursor	Planned	Not implemented yet. No delivery date.
Other agents	Planned	New adapters are welcome through the provider interface.

Switchboard is not trying to replace the agents themselves. It is the place to run, compare, and supervise them alongside the terminals and project state they need. If there is an agent or workflow you want supported, please open an issue or contribute an adapter.

Common workflows

Debug a running service with an agent

Keep the frontend, backend, logs, and database tunnel in terminal panes. When an error appears, select the relevant output and press Cmd+L. The agent gets the error in context without a copy-paste detour or a screenshot of a terminal.

Run several approaches without colliding

Create kanban cards for the work you want to explore. Each card can start an agent in an isolated git worktree, so two agents can change the same repository without sharing a working tree. Review the resulting diffs in chat and keep the approach you want.

Continue work from another machine

Connect to a Linux host over SSH and start a project there. Switchboard provisions its helper, tunnels the connection, and keeps the familiar Claude Code chat, terminal, file, and git surface on your laptop.

Compare or delegate with two chats

Open a conversation, choose Open beside, and select a second loaded chat. The highlighted chat owns the IDE, terminal strip, status bar, Cmd+K, and session-scoped commands; click anywhere in the other chat to switch that binding. Copy prompt → other clones the current draft, pills, and image attachments without linking the two composers. Each side is sent separately, so a provider failure never clears the other draft. Message file links, forks, and Send to other panel always use the message's own conversation.

How it compares

Switchboard overlaps with several excellent tools. The difference is the combination of provider-neutral agent chats, live terminal context, git-aware review, and a project workspace that can run locally or over SSH.

If you need	Consider	Use Switchboard when
A Codex-only multi-agent application	Codex app	You want to work with Claude Code, Codex, and OpenCode in the same workspace, with real terminal processes and remote machines.
An AI-native terminal or saved terminal layouts	Warp	You want rendered provider chats, terminal-to-agent context, git worktree cards, and provider-independent history.
A fast, native terminal for managing CLI agents	cmux	You want the agent conversation, diffs, files, terminals, and project history in one application.
An IDE with built-in agent features	Cursor	You want a workspace centered on agents and live processes. Cursor support is planned, but not available yet.

See it in action

Open any file from the chat in a real VS Code workbench

ide.mp4

Review every edit the agent makes, hunk by hunk

diff-review.mp4

Flip between chats and a worktree-backed board (experimental)

chats-and-board.mp4

Hand the same conversation to a different agent

switch-agent.mp4

Install

Download the latest build from the Releases page.

macOS, Apple Silicon

Download Switchboard-X.Y.Z-arm64-mac.zip. The app is unsigned, so Gatekeeper will refuse the first launch.

# Unzip, drag Switchboard.app to /Applications, then:
xattr -d com.apple.quarantine /Applications/Switchboard.app

You can also right-click the app, choose Open, then choose Open again. macOS may quarantine a replacement after an auto-update, so repeat the command or the right-click flow after an update if needed.

Intel Macs are not currently built. Open an issue if you need x64 support.

Windows, x64

Download Switchboard Setup X.Y.Z.exe. SmartScreen may show "Windows protected your PC" on first launch. Choose More info, then Run anyway. A portable .zip build is also available.

Privacy

Your chats, code and terminal output stay on your machines. The desktop app sends five anonymous counts (launch, session started, tour completed or skipped, crash) with the app version, OS, chip and a random install id, and nothing else. Turn them off in Settings > General > Privacy; development builds never send. Full text at tn07.dev/privacy.

Develop

git clone https://github.com/tejasnafde/switchboard.git
cd switchboard
npm install
npm run dev

Useful commands:

npm test           # vitest
npm run typecheck  # TypeScript checks across main, preload, renderer, and shared
npm run build      # typecheck, tests, bundle, and smoke test
npm run dist:mac   # local Apple Silicon build
npm run dist:win   # local Windows x64 build

npm run dist:* builds for the host platform. Cross-platform release builds run in the GitHub Actions matrix because the Claude Code SDK includes native platform binaries. See docs/releasing.md for the release process.

Under the hood

• One provider interface, three protocols. Claude Code uses the Agent SDK, Codex uses JSON-RPC through codex app-server, and OpenCode uses the Agent Client Protocol. They normalize into one event stream, so the renderer stays provider-agnostic.
• Permissions enforced by the app. Plan mode uses a tested policy that denies non-read-only tools across providers.
• Git is the source of truth for edits. Switchboard takes a checkpoint at the start of a turn and derives review cards from the resulting diff.
• Project context is local and durable. Real PTYs, an embedded VS Code workbench, SQLite with FTS5, encrypted provider credentials, project-scoped history, and .switchboard/workspace.yaml terminal templates are all part of the application.
• Built and tested. The build is gated by typechecking and a suite of more than 1,900 tests.

For the technical details:

• docs/concept.md explains the original product thesis.
• docs/plan.md records the current implementation status.
• docs/architecture/ contains provider and UI details.
• docs/keybindings.md lists shortcuts.
• docs/releasing.md documents releases.

License

MIT © Tejas Nafde