Switchboard
An open-source command center for coding agents, terminals, files, and git worktrees.
Product site | Latest release
https://github.com/user-attachments/assets/75bc0e76-67ba-4d28-aceb-3c8e1db34b14
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, 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
https://github.com/user-attachments/assets/50fc2f7f-7913-4941-a4a5-2e9acf50639f
Review every edit the agent makes, hunk by hunk
https://github.com/user-attachments/assets/c84603bb-1918-4288-bdd3-4d10d83a8ffa
Flip between chats and a worktree-backed board (experimental)
https://github.com/user-attachments/assets/e10797e1-c693-4149-9d08-00a096a9ebb7
Hand the same conversation to a different agent
https://github.com/user-attachments/assets/69252158-50c2-41ff-be7c-377ac2b84ce0
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:
Acknowledgements
Switchboard draws on ideas from other agent tools. Thank you to:
- T3 Code: the multi-instance provider picker, the question card, the context meter and many workspace patterns.
- Omnigent (Databricks): the cross-provider context handoff and the runner model for remote machines.
- vibe-kanban: the user-hosted relay design in the roadmap.
- cmux: the agent-aware terminal design language.
- Warp: declarative launch configurations.
- Cursor: inline context chips, in-chat diff review and the turn duration indicator.
Code taken from other projects keeps its licence notice in THIRD_PARTY_NOTICES.md.
License
MIT © Tejas Nafde
