Skip to content
A hosted MCP gateway for building MCP servers

Build your MCP server. Your agent keeps one URL.

Point your agent at Switchboard once. Run your server on localhost, staging or prod and switch with one command. Watch every call, replay it on another build and diff the answers. Results reach your agent in about half the tokens.

Works with Claude Code, Codex, Cursor and VS Code. Sign up with a passkey or GitHub.

A patch panel of jacks with patch cords between them; a wave of light sweeps across as signals run along the cords.

Your agent connects here, whichever build answers

Switchboard skills for your agent New

Your agent runs the dev loop itself.

Connect your coding agent and Switchboard's skills come with it (or sb skills install-builtin to keep them on disk). It drives sb on its own: it points your endpoint at the build it just changed, switches targets, inspects and replays its calls, and runs your evals. The tedious half of building an MCP server, done by the agent writing it.

Your agent, in its own terminal
# serve the build I just changed behind the same URL
sb dev my-server --port 3000
✓ my-server → local (relay) · 9 tools
# run the eval suite against it
sb eval run evals/my-server.yaml --target local
my-server v4 @local · failed · 412 ms run_9fQ2mT7x
5 passed · 1 failed · 0 errors · 0 blocked · 0 skipped
1 regression · 0 fixed · 0 new vs run_3bH8kR1p
✓ forecast-coast  pass  41 ms
✗ alerts-storm  fail  37 ms  REGRESSION
    path $.alerts min_items 1: expected at least 1 items, found 0
# replay that call on staging and diff
sb compare call_Rt5Wq8Lm2Xk9Jd4H local staging
my-server/get_alerts  local vs staging
Diff (json)
+ $.alerts[0]: {"level":"small craft"}
✗ Results differ (1 change).
# fixed the filter in get_alerts; run it again
sb eval run my-server --target local
my-server v4 @local · passed · 398 ms run_7Lk3sV9q
6 passed · 0 failed · 0 errors · 0 blocked · 0 skipped
0 regressions · 1 fixed · 0 new vs run_9fQ2mT7x
✓ alerts-storm  pass  35 ms  fixed
  • Points your endpoint at its build

    The agent starts sb dev for the code it just wrote, or switches targets with sb use. You keep one URL in its config.

  • Reads the calls it made

    It tails and opens its own calls, then uses sb replay and sb compare to check a fix on another build.

  • Runs your evals before it says done

    sb eval run on the build it changed, with regressions against the last run. Exit codes it can act on.

The skills only use the same sb commands you can run by hand. Tools that are not marked read-only still ask before a replay runs them.

The dev loop

Switch builds. Keep your agent connected.

Run your server on your laptop, on staging or in production, and pick which one answers with one command. Same tool names, same sign-in, no restart.

Your agent's cable is re-patched from build A (local) to build B (staging); their two answers appear side by side with the one changed line marked.
Your agent calls my-server__get_forecast. Pick the build that answers.
Your agentSwitchboardmy-server
sb dev
sb dev my-server --port 3000
my-server · relay target local → http://127.0.0.1:3000/mcp
relay attached; switching my-server to local…
✓ my-server → local (relay) · 9 tools
  agents using my-server__* now reach your machine. Ctrl-C to stop and switch back to staging.
14:02:07 tools/call get_forecast 41 ms 200 1.8 kB
✓ tools changed: +get_tides · catalog refreshed (10 tools)
14:02:31 tools/call get_tides 37 ms 200 912 B
^C
✓ restored my-server → staging · 9 tools
sb use
sb use my-server staging
Refreshing staging…
✓ my-server now answers from staging · 9 tools (+1, −0)
  + get_alerts
  Agents see the new tools from their next call (direct-mode clients may keep the old list up to ~60 s or until they reconnect).
sb use
sb use my-server prod
Refreshing prod…
✓ my-server now answers from prod · 8 tools (+0, −1)
  - get_alerts
  Agents see the new tools from their next call (direct-mode clients may keep the old list up to ~60 s or until they reconnect).
  • One server name, every build

    Keep local, staging and prod under one server. Your agent always calls my-server__get_forecast, whichever build answers.

  • Switch in one command

    sb use my-server staging reads the build's tools, then swaps. Your agent gets them from its next call. If the build does not answer, nothing changes.

  • Your localhost, no tunnel

    sb dev my-server --port 3000 puts the server on your laptop behind your hosted MCP URL, with no public address. Tools you add show up within seconds. Ctrl-C switches back.

sb compare
sb compare call_7Hk2pQx9LmT4vR8sWd3e local staging
my-server/get_forecast  local vs staging
        LOCAL   STAGING
result  ok      ok
time    41 ms   58 ms
size    1.8 KB  1.9 KB
tokens  912     951

Diff (json)
~ $.alerts: 0 → 1
+ $.advisory: "Small craft advisory"

✗ Results differ (2 changes).

Same call, two builds, one diff

Pick any recorded call and run it again on another build with sb replay, or on two builds at once with sb compare. Switchboard shows both answers side by side with what changed: fields, values, size and time.

Tools that are not marked read-only ask before they run. sb compare exits 1 when the answers differ, so it can gate a deploy. In the dashboard, open a call and pick Compare A/B.

A call trace: get_forecast goes to my-server@local, its 1,840-token raw result is compacted to 912 tokens, and the answer reaches the agent in 41 ms.

See what the agent got

sb calls --tail follows every call. Open one to see the request, what your server sent and what the agent received, side by side. Secrets are redacted; records expire after 7 days. Capture is opt-in, and always on for sb dev.

Inspector
sb calls --tail
14:02:07  my-server@local  get_forecast  ok  41 ms  1840→912  claude-code  call_7Hk2pQx9LmT4vR8sWd3e
14:02:19  my-server@local  get_tides  error  9 ms  156  claude-code  call_Q2nV8cJr5ZyB1tKa6Ufh
14:02:31  my-server@local  get_tides  ok  37 ms  612→402  claude-code  call_mX4Lw0dG7sPe3NqY9Tbc
On every call

Same answers. About half the tokens.

Switchboard compacts tool results and tool lists before your agent reads them, so a long test session leaves more room in the context window. It is on by default for every server you connect, with one switch to turn it off.

A pretty-printed JSON tool list folds into a short TOON table: 3,701 tokens become 1,643, 56% fewer.
Smaller find_tools responses
56%

3,701 to 1,643 tokens

Smaller tool lists
57%

12 GitHub-style tools

Change to prose, errors and images
0%

They pass through untouched

What the server sends28 lines

Pretty JSONjson
{
  "issues": [
    {
      "id": "ISS-142",
      "title": "Retry webhook on 502",
      "state": "open",
      "priority": 1,
      "assignee": "ana",
      "labels": "",
      "estimate": null,
      "url": "https://tracker.example/ISS-142"
    },
    {
      "id": "ISS-143",
      "title": "Paginate audit export",
      "state": "in_progress",
      "priority": 2,
      "assignee": "chen",
      "labels": "",
      "estimate": null,
      "url": "https://tracker.example/ISS-143"
    }
  ],
  "pageInfo": {
    "hasNextPage": true,
    "endCursor": "Y3Vyc29yOjUw"
  }
}

What your agent reads6 lines

TOON
issues[2]{id,title,state,priority,assignee,url}:
  ISS-142,Retry webhook on 502,open,1,ana,"https://tracker.example/ISS-142"
  ISS-143,Paginate audit export,in_progress,2,chen,"https://tracker.example/ISS-143"
pageInfo:
  hasNextPage: true
  endCursor: Y3Vyc29yOjUw
Two rows of an issue list, as the server sent them and after Switchboard. Same fields, same values: empty columns are dropped and the rows become a table.
Tokens per response, before and afterMeasured with the o200k tokenizer on real-shaped payloads, against pretty JSON.
  • find_tools response8 tools and 2 skills3,701 to 1,643 tokens56% fewer
  • Tool list12 GitHub-style tools5,442 to 2,354 tokens57% fewer
  • Issue list50 flat issues4,696 to 2,119 tokens55% fewer
  • Nested issues30 GitHub REST issues9,165 to 5,491 tokens40% fewer
  • ProseA plain-text answer1,289 to 1,289 tokensUnchanged
  • The smaller format wins

    Lists of similar records go out as TOON: one header, then one line per record. Everything else goes out as minified JSON. TOON is used whenever it is smaller by 5% or more; at scale, every percent counts.

  • Leaner tool lists

    Tool descriptions and schemas lose the noise: $schema, titles, examples and run-on text. Property names and validation rules stay exactly as the server wrote them.

  • Big results capped, out loud

    An oversized result is cut from the end of its longest list, with a note saying how many items were left out and how to page for the rest. Errors, images and prose pass through untouched.

On by default. Turn it off for the whole workspace in Settings, or for one server that needs the raw output. The dashboard shows tokens saved per server, tool and client.

Beyond your own server

The servers you use, behind the same URL

Add servers by URL and sign in once. Switchboard keeps the tokens, refreshes the tool lists, and hands each conversation the handful of tools and skills that fit it, so you never have to say “use X”.

Several upstream MCP servers are cabled into one Switchboard plate, and a single cable runs from it to your agent.
find_tools · example
find_tools  "why did last night's deploy fail?"

  tool   github__list_workflow_runs
  tool   sentry__search_issues
  tool   linear__search_issues
  skill  deploy-triage

Example. The agent describes the task; Switchboard returns the few tools and skills that match. In our offline test of 53 requests over 64 tools and skills, the right one was in the top 5 about 94% of the time.

  • Add by URL, sign in once

    Paste a remote MCP server URL. If it uses OAuth, a popup signs you in and Switchboard keeps the tokens, encrypted, and refreshes them. Header and bearer auth work too.

  • Tools picked from the conversation

    Semantic search over every tool and skill description. Your agent sees the few that fit, not hundreds of schemas.

  • Tool lists kept fresh

    Switchboard re-reads each server's tools in the background and backs off when a server is down. Switch a server or skill off without removing it.

Also in the box

Everything here is live today.

  • Any server, latest spec

    Old and new MCP servers alike reach your agent as current MCP. Switchboard negotiates each one's protocol version and falls back when needed.

  • Structured output, checked

    Output schemas pass through and results are validated. JSON-only text arrives as structured data too. A broken result falls back to text, not an error.

  • Titles and safety hints kept

    Tool titles, icons and annotations like read-only and destructive reach your agent exactly as each server declares them.

  • Skills, uploaded or imported

    Upload a SKILL.md bundle, or connect a server that publishes skills and Switchboard imports them. Agents load them through the same URL.

  • Metrics and cost

    Calls, success rate, p50/p95 latency and tokens saved, by server, tool and client. Estimated cost saved for Claude clients, labelled as an estimate.

  • Call inspector

    Opt-in capture of the request, what the server sent and what the agent got. Secrets redacted, kept 7 days.

  • Evals for your server

    Cases in a YAML suite, run on any build with sb eval run or from the dashboard. Regressions are compared with the last run, and the exit code can gate CI.

  • Skill lint

    sb skills lint checks skills, plugins and marketplaces against the Agent Skills spec, offline, with GitHub annotations for CI.

  • Passkeys, GitHub and OAuth

    Sign in with a passkey or GitHub. Agents connect with OAuth or a personal access token. Upstream tokens are encrypted at rest.

  • Runs on Cloudflare

    The gateway, dashboard and dev relay run on Cloudflare Workers, D1, R2 and Durable Objects. Nothing to host.

Three steps to one URL

Everything happens in the dashboard or the sb CLI. Nothing to install on the server side.

  1. Add your servers

    Paste each MCP server URL. Servers that use OAuth open their sign-in in a popup; the rest connect right away. Skills they publish come along.

  2. Add your skills

    Upload a SKILL.md with the files it references. Switch any server or skill off without removing it.

  3. Connect one URL

    Add your Switchboard URL to each agent and sign in when it asks. They all see the same servers and skills from then on.

Agent configuration

The same URL works in Cursor, VS Code and any client that speaks streamable HTTP.

Claude Codeshell
claude mcp add --transport http --scope user switchboard https://switchboard.yogan.dev/mcp
~/.codex/config.tomltoml
[mcp_servers.switchboard]
url = "https://switchboard.yogan.dev/mcp"

sb, the Switchboard CLI

Sign in from the browser, then do from a terminal what you'd do in the dashboard.

sb
sb login
sb servers list
sb use my-server staging
sb dev my-server --port 3000
sb calls --tail
sb compare call_7Hk2pQx9LmT4vR8sWd3e local staging
login
Sign in from the browser, no token pasting
servers
Add, list and refresh servers; add with --oauth
skills
List, upload and lint skills
targets · use
Keep builds under one server and switch between them
dev
Relay a server on localhost to your MCP URL
calls
Tail and show calls; turn capture on or off
replay · compare
Run a recorded call again, or on two builds and diff
eval
Run an eval suite on a build; exit 2 on a regression
search
Try routing from the terminal
connect · doctor
Print agent config; check your setup

Coming next

Planned and not built yet. We'll move them up the page when they ship.

Teams

Coming

Invite people by email, limit them to some servers, see usage per member, and revoke access in one click.

Skills from a git repo

Coming

Paste a repo URL and install every skill in it, pinned to a commit, with updates you review.

Point your agent at your server

Create an account with a passkey or GitHub, add your server, and connect your agent. Then switch builds as often as you like.

Quick start
sb login
sb connect claude-code
sb dev my-server --port 3000