# MCP registry vs MCP gateway: what each one does, and why you need both

> An MCP registry decides which MCP servers exist and are approved. An MCP gateway enforces policy on every call. What each one does, where it sits in the request path, and what neither of them solves.

Language: en · Category: engineering · Author: Nicolas Corod (Founder & CEO) · Published: 2026-11-01

## TL;DR

**An MCP registry decides which MCP servers exist and which are approved: it is a catalogue of server metadata, consulted before any connection. An MCP gateway sits in the request path between agents and servers and enforces authentication, policy and logging on every call.** The registry governs what can be connected. The gateway governs each connection as it happens.

Both terms are showing up in architecture diagrams at the same time, often used as if they were interchangeable. They are not. They answer different questions, sit in different places and fail in different ways. This explainer separates them, then names the part of the problem neither one solves.

## First, the moving parts

The [Model Context Protocol](https://modelcontextprotocol.io) (MCP) is an open protocol that lets an AI agent discover and call tools, read resources and fetch context from other systems through a standard interface. An **MCP server** exposes those tools: a CRM connector, a ticketing system, an internal API. An **MCP client** is the agent side: Claude, ChatGPT, Copilot, an IDE assistant or an in-house agent.

Once an organisation has more than a handful of servers and more than one client, two questions appear:

1. Which servers are we allowed to use, in which version, configured how?
2. When an agent calls a tool on one of them, is that call allowed, for this user, and what did it do?

The first question is a registry question. The second is a gateway question.

## What an MCP registry is

A registry is a catalogue. Each entry describes an MCP server: its name, what it does, where it runs, which version is current, who maintains it, and in an enterprise registry, whether it has been approved and how it is configured.

The reference example is the official [MCP Registry](https://blog.modelcontextprotocol.io/posts/2025-09-08-mcp-registry-preview/), launched in preview on 8 September 2025 at `registry.modelcontextprotocol.io`. It describes itself as an open catalogue and API for publicly available MCP servers. Three design choices matter for an enterprise reader:

- **It stores metadata, not code.** Maintainers publish self-reported information about their servers. The registry does not host or run them.
- **It is built for sub-registries.** Public sub-registries can enrich the upstream data, and private sub-registries can exist inside enterprises with stricter requirements, building on the same interface.
- **Moderation is reactive.** Community members flag entries that break the moderation guidelines, and maintainers can denylist them.

That makes the public registry a good discovery source and a poor approval source. It tells you a server exists. It does not tell you that it is safe to connect to your ERP.

An **enterprise registry** closes that gap by being curated rather than open: it lists only servers that have been reviewed, credentialed and scoped for the organisation. Adding a server to it becomes the authorisation step. Everything downstream can then refuse anything that is not in the list.

What a registry does not do is watch the traffic. Once a client holds a server's address and a token, the registry is not in the path of the calls.

## What an MCP gateway is

A gateway is a proxy. Agents connect to the gateway instead of connecting to each MCP server directly, and the gateway forwards calls to the servers behind it. Because every call passes through it, it can act on every call:

- **Authenticate the caller** and map the agent session to a real user.
- **Apply policy per tool**: allow a read tool, block a write tool, require approval for a destructive one, filter the tool list a given user sees.
- **Manage credentials** to the downstream systems, so agents never hold them.
- **Record** which user, through which agent, called which tool with which arguments, and what came back.
- **Aggregate and route**, presenting several servers behind one endpoint.

The MCP specification is strict about how a component in this position must handle identity. Its [security best practices](https://modelcontextprotocol.io/specification/2025-11-25/basic/security_best_practices) describe "token passthrough", where a server accepts a client's token and forwards it downstream, as an anti-pattern that the authorization specification explicitly forbids: MCP servers must not accept tokens that were not issued for them. The same document describes the confused deputy problem for MCP proxies that talk to third-party APIs, and requires per-client consent to prevent it. A gateway worth deploying has to get these details right, because it concentrates exactly the credentials an attacker wants.

What a gateway does not do is decide what should be behind it. It enforces rules on the servers it is pointed at, whether or not anyone reviewed them.

## Side by side

| | MCP registry | MCP gateway |
|---|---|---|
| Question it answers | Which servers exist and which are approved? | May this call happen, for this user, now? |
| Position | Outside the request path | In the request path |
| When it acts | Before a connection: discovery, review, versioning | During every call: auth, policy, logging |
| What it holds | Server metadata, versions, approval status, configuration | Sessions, credentials, per-tool policy, call logs |
| Typical owner | Platform or architecture team | Security or platform team |
| Failure when missing | Anyone connects anything; no lifecycle | Approved list, no enforcement or trace at runtime |

## Do you need both?

At small scale, no. One team, three servers, one client: a shared config file and good habits will do.

At enterprise scale, the two fail in complementary ways when used alone.

**A registry without a gateway** gives you an approved list that nothing enforces. A developer can still paste an unapproved server URL into a client, and nobody sees which approved server was called for what. This is how ungoverned connections spread, the same way consumer chatbots spread before them.

**A gateway without a registry** enforces policy on whatever someone pointed it at. There is no review step, no version history and no single place to deprecate a server across every team. The gateway becomes a registry by accident, managed through its configuration file.

Used together, the registry is the source of truth for what may be connected, and the gateway, or any component in the request path, enforces that truth call by call.

## What neither of them solves

Registries and gateways are about connectivity and control. They answer "can this agent reach this tool?" They do not answer "how should this agent use these tools to do this job, the way your company does it?"

That knowledge (which tools a task needs, in which order, under which business rules) is know-how, and it lives in a separate layer: skills. The argument is made in detail in [composing skills over MCP](/en/blog/mcp-vs-skills-composing/). The practical consequence is on the context window: connecting an agent to every approved server loads every tool definition before any work begins, a problem described in [from context bloat to context load](/en/blog/context-bloat-to-context-load/). Picking the right tool at the right moment is its own discipline, covered in [retrieval is the new intelligence](/en/blog/retrieval-is-the-new-intelligence/).

## Where skilder fits

skilder's MCP server registry is internal to each workspace and curated: it holds only servers that have been vetted and pre-configured (reviewed, credentialed and scoped). It is not a public directory of MCP servers. Adding a server to it is the central authorisation step, and a **role**, skilder's primitive, can only reach servers that are already in the registry.

A role bundles skills, scoped MCP tools, context and permissions, starting from a blueprint configured on the team's own processes. Roles are served to Claude, ChatGPT, Copilot or any MCP-compatible client through skilder's own MCP server, with tools loaded on demand, the role as the permission boundary, and every task logged and attributable to the person who ran it. The connection flow and its authentication details are in the [skilder documentation](https://docs.skilder.ai).
