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

Every MCP server. One secure gate.

Want to easily and safely connect your agents (Claude Code, Codex, Kotrain, Cursor, Devin, etc.) to services like GitHub, Vercel, Slack, or Google Drive? Hypergate makes it easy, and provides a safety layer where the authentication, keys, and permissions aren't in the hands of an agent if things go bad.

Download Hypergate latest
View GitHub repo ↗
Terminal $ Detecting the right install command…

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

Claude Code✦Cursor✦Kotrain✦Codex✦VS Code

Security

Control what every agent can reach

Agents accumulate MCP servers quietly, and most setups can't answer the basic questions: which servers are installed, what is actually being called, and which agent is doing the calling. Every call runs through a gate you own, so those answers are always one screen away, and access is a switch you flip rather than a config file you go hunting for.

  • Per-agent allow-lists: grant, scope, or revoke a server in one click
  • Every tool call attributed to an agent, timed, and logged on your machine
  • Server credentials and OAuth tokens stay in Hypergate, never in agent configs
  • Each agent gets its own bearer token, so revoking one leaves the rest running
Hypergate access-control view with Claude Code expanded to show its masked token and access to GitHub, Filesystem, Postgres, and Vercel

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 MCP servers view with GitHub, Filesystem, and Postgres running, Vercel awaiting a token, and per-agent access counts

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 overview with 26 calls at 100 percent success across three agents and usage by GitHub, Filesystem, and Postgres

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 OAuth servers and recommended connection guidance for Context7, Supabase, Linear, Figma, and GitHub

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 GitHub server detail showing a typed tool schema, connected-agent permissions, and local logs

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 tools view showing installed Node.js, npx, and npm with versions and system paths

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.

Download Hypergate latest
View GitHub repo ↗