Switchboard Hosted · MCP gateway for teams

Give every agent your tools. Keep control of all of them.

One governed MCP endpoint for your whole team. Connect GitHub, Slack, Datadog, Postgres, and 30+ more once, set who can use what, and see every call in the audit log. Works with Cursor, Claude Code, Codex, and any MCP client.

Start free See pricing

Free for up to 3 members No credit card Source-available core

Works with any MCP client

Cursor Claude Code Codex Windsurf VS Code Claude Desktop

Architecture

How Switchboard sits between your agents and your infrastructure

Clients connect to one URL. Switchboard authenticates the member, applies policy, injects encrypted credentials, and runs the tool. Nothing about your model or client changes.

~/.cursor/mcp.json Client config

{
  "mcpServers": {
    "switchboard": {
      "url": "https://your-org.switchboard-mcp.com/mcp"
    }
  }
}

One URL. Every tool. Every client.

Drop the same endpoint into any MCP client. Members sign in with OAuth or an sb_ API key, and their access follows the policies you set, not whatever is in a local config file.

Platform

Everything a team needs to run MCP in production

Governance your security team can sign off on, without slowing down the developers using it.

One endpoint, every tool

Replace a dozen per-developer MCP servers with one managed gateway. Add or remove integrations centrally and every client picks them up.

Policies that decide who reaches what

Glob and CEL policies scoped to members, departments, or the whole org. Deny rules always win, so one default policy can cap every grant.

Audit log for every change

Member changes, policy edits, key creation, integration config, and tool calls are recorded with actor, action, and timestamp.

SSO, departments, and SCIM

Organize members into departments, sync groups from your identity provider, and turn on SSO on the Business plan and up.

Private-data tunnel

Query Postgres and Kubernetes behind your firewall through an outbound-only agent you run. No inbound ports, no credentials in the cloud.

Skills and shared todo lists

Share reusable agent skills and durable todo lists across the org, entitled through the same policies as your tools.

Governance

Policies your security team can read

Stop hardcoding credentials into individual developer machines. Write a policy once, test it against a real member before saving it, and know exactly which agent can reach production data.

Member, department, and org-default policies
Glob tool filters and CEL expressions over subject and resource
Simulate any policy against a real member before you ship it
Scoped API keys bounded by exactly the policies you pick

policies / datadog-for-platform CEL policy

// Platform engineers can use read tools on Datadog
subject.in_department("platform") &&
resource.integration == "datadog" &&
"read" in resource.tags

Simulate

alex (platform)datadog_query_metricsallowed

sam (sales)datadog_query_metricsdenied

agent session meta-tools

# 1. Find only the tools this task needs
search("github pull request changes")
  github_get_pull, github_get_pull_diff

# 2. Run one, or chain several server-side
execute("github_get_pull_diff", { pull_number: 42 })
  compacted before it reaches the model

~90% fewer tokens per tool call Response compaction plus on-demand schema discovery

Token efficiency

36+ integrations without blowing up the context window

Most gateways dump every tool definition into the prompt. Switchboard exposes two meta-tools, search and execute, so adding your fortieth integration costs nothing on unrelated calls.

2meta-tools instead of hundreds of schemas

~90%fewer tokens after response compaction

Integrations

Your whole stack behind one endpoint

Built-in integrations for the tools your team already uses, plus OpenAPI and GraphQL imports when you need something custom.

AWS

GCP

Postgres

Stripe +29 more

Who it's for

Built for teams moving MCP from prototype to production

Platform and DevEx

Roll out MCP to the whole org from one place. Push config without touching a developer's machine and onboard new hires with zero credential sharing.

Central config

Security and compliance

Credentials encrypted at rest, policies deciding who reaches what, and an audit log that proves it. Private data stays behind an outbound-only tunnel.

Least privilege

Developers

Skip the per-tool setup dance. One endpoint in Cursor or Claude Code and your agent can reach everything it is allowed to, with far fewer tokens per call.

One URL

Compare

Governed gateway vs. MCP sprawl vs. lock-in

DIY MCP works until you have a team. Vendor agent hubs work until you want out. Switchboard is the portable middle.

	Raw MCP servers	Vendor agent hubs	Switchboard Hosted
Setup per developer	One config entry per tool	Per-tool connectors	One endpoint URL
Credential storage	Plaintext local files	Vendor cloud	AES-256-GCM vault, per org
Access control	None	Basic roles	Glob + CEL policies, departments
Audit log	None	Varies	Every mutation and tool call
Context cost	Full tool catalog in prompt	Varies	search + execute meta-tools
Data behind your firewall	Manual	Rarely	Outbound-only tunnel
Client and model choice	Whatever you wire	Often one suite	Any MCP client, any model
Exit path	Your configs	Usually closed	Source-available core (ELv2)