Local-first MCP runtime & manager · open source · MIT

Every MCP server. One gate.

Hypergate runs your MCP servers on your own machine: sandboxed, supervised, and aggregated behind a single gateway endpoint. Point Claude Code, Cursor, Open Paw, or any agent at one URL and jump.

Get Hypergate on GitHub See it running ↓
$ claude mcp add -t http hypergate http://localhost:7777/mcp
1gateway URL for every agent
3isolation modes, your choice
0bytes leave your machine

Speaks standard MCP, so every harness already knows the way in

Claude Code✦Cursor✦Open Paw✦Codex✦VS Code

The gateway

One endpoint, every agent

Run six servers or sixty: your agents see a single MCP endpoint with every tool namespaced behind it. Copy a ready-made snippet for Claude Code, .mcp.json, stdio, or Open Paw, and hand scoped tokens to each agent with per-server allow-lists.

  • Streamable HTTP and stdio transports
  • Bearer-token auth, generated and enforced by default
  • Scoped tokens per connected agent
Hypergate gateway bar with connect snippets for Claude Code, .mcp.json, stdio, and Open Paw

The runtime

Sandboxed, supervised, yours

Hypergate is a real server runtime, not a connector list. It launches each server in its own sandbox, injects secrets at spawn, watches health, captures logs, and restarts what falls over. Toggle, inspect, and stop everything from one calm list.

  • Scrubbed env, injected secrets, restricted CWD, resource limits
  • Status, structured logs, and restart per server
  • Remote OAuth servers sit alongside local ones
Hypergate servers view: Fly.io process server, Context7 remote server, GitHub awaiting sign-in, and scoped connected agents

Analytics

An audit trail for free

Because every call fans through the gate, you get observability without wiring anything: which tool, called by which agent, how long it took, how many bytes each way. All of it stays on localhost.

  • Per-server, per-tool, and per-agent breakdowns
  • 24-hour call sparkline and a live recent-calls feed
  • Persists across daemon restarts
Hypergate analytics: 26 tool calls at 100 percent success across 4 clients, usage by server and a who's-calling breakdown

The catalog

A catalog that signs you in

Curated first-party servers, ranked by real npm and GitHub popularity, with trust chips so you can tell official from community at a glance. OAuth servers add with one click: the browser opens, you approve, Hypergate connects. The whole official MCP registry is a search box away.

  • ✓ Official and Community trust chips
  • One-click OAuth: Context7, Supabase, Linear, Figma, GitHub
  • Registry search mapped straight into add-ready entries
Hypergate catalog with official trust chips and one-click OAuth sign-in-and-add buttons for Context7, Supabase, Linear, and Figma

The inspector

X-ray every tool

Expand any server into its full tool list, then open a tool to see its description and typed parameters, parsed from the live schema. Know exactly what your agent can reach before it reaches.

  • Live tool schemas straight from the server
  • Required flags and types at a glance
  • Namespaced names match what agents actually call
Hypergate tool inspector showing Fly.io tools with typed parameters and required flags

CLI radar

Knows what your machine can run

MCP servers lean on CLIs: node, uvx, docker, cloud tools. Hypergate detects what's installed, shows versions and paths, points at install docs for what's missing, and lets you check any command on PATH. Fully local, no shell, injection-guarded.

  • 22 known CLIs probed with version and path
  • Install hints for anything missing
  • Ad-hoc search for any command
Hypergate CLI detection: Node.js, npx, npm, Bun installed with versions and paths, Deno missing with an install hint

Secure by choice

Pick your shielding

Isolation is a tradeoff, so Hypergate makes it explicit instead of forcing a dependency. Choose at setup, override per server.

Process sandbox default

Servers run as sandboxed child processes: allow-listed env, injected secrets only, restricted working directory, resource limits, no shell.

Zero dependencies, instant start, cross-platform. The honest caveat: it shares your kernel, so it's a lighter boundary than a container.

Docker opt-in

Container per server: pinned image, dropped capabilities, no-new-privileges, CPU and memory limits. ToolHive-grade isolation for untrusted community servers.

Requires Docker and a slower cold start. Never mandatory.

Remote hosted

No local process at all: the gateway connects to a provider's hosted MCP endpoint over OAuth. One browser approval, tokens stored locally.

First-party servers like GitHub and Context7. Trust shifts to the provider, and nothing phones home from your machine.

Quick start

Open the gate

$ git clone https://github.com/nekko-labs/hypergate && cd hypergate
$ npm install && npm run build
$ npm run daemon
hypergated listening on http://localhost:7777
gateway → http://localhost:7777/mcp

Then open localhost:7777, add servers from the catalog, and paste the gateway snippet into your agent. That's the whole setup.

Star it on GitHub