
Once an enterprise moves past its first few MCP servers, three new words start showing up in architecture reviews: registry, runtime, and gateway. Vendors use them differently, some products claim all three, and teams end up debating which one they need first.
The answer is easier once you see that each one answers a different question. A registry answers what exists. A runtime answers where it runs. A gateway answers who can do what, on every call. This guide explains each layer, how a single agent request passes through all three, and how to decide what your organization needs.
The short answer
An MCP registry is the catalog of MCP servers your organization knows about and has approved. An MCP runtime is the environment where MCP server code actually runs and holds the credentials it uses. An MCP gateway is the control point between agents and servers that checks identity and policy on every tool call and records the result.
| Registry | Runtime | Gateway | |
|---|---|---|---|
| Question it answers | Which servers exist, and which are approved? | Where does server code run, and how does it hold credentials? | Who can call which tool, with what inputs, right now? |
| What it holds | Server metadata, versions, owners, approval status | Running server processes, secrets, network access | Identities, roles, policies, and call logs |
| When it acts | Before anyone connects | While a tool executes | On every request, before the tool runs |
| What it can’t do alone | Stop a bad call | Decide which user should be allowed | Know about servers nobody connected through it |
| Typical owner | Platform or AI governance team | Platform or infrastructure team | Security and platform teams together |
What an MCP registry does
A registry is the list of record. It describes each server: name, publisher, version, where it runs, how to connect, and whether it’s approved. The official MCP Registry, launched in preview in September 2025, is a public catalog of this kind, and its charter is explicit that it is “a metadata catalog, not a package registry.” It doesn’t host servers or run them.
Enterprise registries add what a public one doesn’t: internal approval, owners, and scoping by team or role. They answer “are we allowed to use this server?”
What a registry can’t do is enforce anything at the moment of a call. It only knows what was registered, and it has no say once an agent starts sending requests.
What an MCP runtime does
A runtime is where MCP server code actually executes. That might be a developer’s laptop running a local server, a container in your cloud, or a managed service that hosts servers for you.
The runtime’s job is operational and security-critical at the same time:
- Isolation. Server code runs with limited access to the host, network, and file system. The MCP security best practices warn that local servers can have direct access to a user’s system and recommend sandboxing them.
- Credentials. The runtime holds the secrets a server uses to reach the underlying app. Those secrets should never pass through the model.
- Reliability. Scaling, restarts, timeouts, and version upgrades all happen here.
A runtime answers “where does this code run, and is it safe?” It doesn’t, on its own, decide which user or agent is allowed to call which tool.
What an MCP gateway does
A gateway sits between agents and MCP servers, wherever those servers run. Every request passes through it, so it’s the one place that can apply policy consistently:
- Identity. It knows which agent is calling and which person the agent is acting for.
- Least privilege. It decides which tools, and which parameters, that identity can use.
- Inspection. It can check tool definitions before they’re exposed and inputs and outputs as they flow.
- Logging. It records every call, including the ones it denied.
A common misconception is that a gateway is just a router using one shared service account. That design exists, and it’s the weakest version of the pattern, because every user ends up with the same access. An identity-aware gateway applies each person’s permissions, which is what makes it a security control rather than a convenience. For a closer look at how this differs from the API gateways most enterprises already run, see MCP gateway vs API gateway.
How one request flows through all three
Here’s a single agent request, end to end.
- Before anything runs, the registry lists the CRM server as approved, owned by the sales platform team, at a specific version.
- An agent asks for its tools. The gateway checks who the agent is acting for and returns only the CRM tools that person’s role allows, with tool definitions already scanned.
- The agent calls a tool, for example to update an opportunity. The gateway checks the call against policy: is this tool allowed, are these inputs within limits, does this action need human approval?
- The call reaches the runtime, where the CRM server runs in isolation, uses its stored credentials to reach the CRM, and returns a result.
- The result returns through the gateway, which can inspect it for sensitive data or injected instructions, then logs the whole exchange.
Each layer does one job. Remove any of them and something important goes missing: no record of what’s approved, no safe place for code and secrets, or no check at the moment of action.
The gap between them: servers nobody registered
All three layers share one blind spot. They only see what’s connected to them. A developer who adds a local MCP server to an IDE, or a team that calls a server directly from application code, bypasses the registry and the gateway entirely.
That’s why discovery belongs next to these three layers. Continuous discovery finds MCP servers running on endpoints, in code repositories, and in cloud environments, so they can be reviewed and moved onto the governed path. Without it, the registry describes the servers you know about, not the ones you actually have.
How to decide what you need
Most organizations build in this order.
- Start with discovery. Find the MCP servers already in use before you design anything.
- Put a gateway in front of agents. It gives you identity, least privilege, and logging immediately, even for servers you don’t host yourself.
- Formalize the registry. Turn the gateway’s approved list into the source of truth for which servers and versions are allowed.
- Decide where code runs. Move high-risk local servers into isolated, managed environments, and keep credentials out of developer machines.
A few questions help when evaluating products that claim one or more of these layers:
- Does the gateway enforce each user’s permissions, or one shared account?
- Can access be set per tool and per parameter, not just per server?
- Are tool definitions scanned before an agent sees them?
- Is every call logged, including denied ones?
- Do the registry, gateway, and runtime share one identity and policy model, or does each have its own?
- What happens to servers that never connect through any of them?
How Airia fits
Airia focuses on the control and visibility layers and works with MCP servers wherever they run, from its catalog of pre-configured servers to custom ones your teams build.
The Airia MCP Gateway is the control point for agent tool access. Admins approve which servers can be used at all, which gives you an enterprise registry of approved servers, and connect the app credentials those servers need. Access is assigned at the app, tool, and parameter level by role, and a single Dynamic MCP Gateway address serves every user a tool set matched to their role. Every tool’s name and description is scanned for hidden prompt injection before it’s exposed, and every call, whether it succeeded, was denied, or errored, is logged and searchable. Airia Radar helps agents find the right tool in large catalogs without loading every definition into the context window.
Airia Discover closes the gap between layers. MCP Server Detection and code repository scanning are among its nine discovery signals, so servers nobody registered show up in your AI inventory. Agent Constraints add deterministic checks on tool inputs and route high-impact actions to human review.
Conclusion
Registries, runtimes, and gateways aren’t competing options. They’re three layers that answer three questions: what’s approved, where it runs, and who can do what right now. Build them on one identity and one policy, add discovery for what slips past all three, and MCP becomes infrastructure your security team can stand behind.
See your MCP layers working as one. Request a demo to watch Airia find unregistered servers, approve the right ones, and govern every tool call from a single gateway.
Put these ideas to work.
Schedule a 30-minute walkthrough with our team.