A unified MCP control plane gives platform engineering teams one gateway and registry for identity, tool-level policy, and audit, so they do not have to rebuild security for each AI project. Runlayer is one implementation of this pattern. The architecture that holds at fleet scale defines policy centrally, enforces it on every tool call, and makes discovery automatic without making access automatic.
Why MCP infrastructure needs a control plane and what happens when it doesn't have one
MCP standardizes how agents connect to tools through JSON-RPC 2.0. It is not a policy engine. A common interface does not decide who may call a tool, which credentials it may use, or what evidence an action must leave. The protocol leaves authentication, authorization, and audit to implementers, so independent integrations become independent security decisions.
Uber’s MCP Gateway account describes the operational result. Early integrations showed value, but separate teams built duplicated infrastructure, tools became hard to discover, and integrations stayed tightly coupled to particular services or agents. Those patterns broke down as hundreds of teams explored agentic workflows. The NSA’s May 2026 guidance states that MCP alone cannot enforce consent, privacy, or tool-safety principles. Individual teams have no alternative to making isolated decisions under the protocol.
The Kubernetes analogy that explains what a control plane actually does for MCP
Kubernetes provides a useful frame. Its control plane defines desired state, while its data plane executes that state. Policy and execution have separate jobs. Applied to MCP, this means defining access centrally without requiring every server to become its own governance system.
The MCP control plane declares which servers exist, who may call their tools, which credentials are permitted, and what must be logged. The proxy gateway applies those rules to agent-to-server calls. Enforcement sits outside the model’s reach. Policy can thus change across the fleet without changes to each server, and a model cannot use instructions to rewrite the infrastructure’s access decisions.
Uber separates these responsibilities into its MCP Registry and Proxy Gateway. The registry owns discovery, ownership, and enablement, while the proxy executes requests, translates protocol calls, and routes them to backend services. Crucially, discovery does not imply exposure. Servers and tools begin disabled and require explicit review and enablement by their owners.
The four-layer stack that production deployments are converging on
Identity is the first layer of the stack. An enterprise identity provider, such as Okta or Entra ID, supplies the identity context for short-lived access. The control plane manages OAuth relationships and brokers credentials while keeping raw secrets out of clients.
Access control is the second layer, with permissions tied to identity-provider groups and enforced for individual tools. Translation and registry form the third layer. Legacy APIs, gRPC services, databases, and SaaS applications become MCP servers with declared schemas, while the registry records what exists and who may use it. Unapproved connections are blocked or surfaced as detection events.
Audit completes the stack at the tool-call boundary. That position connects identity, authorization, and execution in one decision chain. Obot’s enterprise architecture describes the same four components, with governance centralized in a layer that servers share. AWS’s 2026 stack maps these responsibilities to AgentCore Identity, Gateway, Policy, and Observability, with CloudTrail providing a separate audit mechanism. The components differ, but their responsibilities remain distinct.
Why identity must be resolved at the control plane, not carried by the agent
Credentials in agent context turn a compromised interaction into a possible route to downstream systems. Shared credentials widen that exposure further. If several MCP servers use the same credential, its compromise affects everything that credential can reach. Credential isolation therefore establishes the boundary on which later authorization depends.
Wiz Research disclosed CVE-2026-12957 in the Amazon Q VS Code extension on June 26, 2026. A malicious repository could use a crafted.amazonq/mcp.jsonfile to achieve arbitrary code execution and cloud credential theft. Spawned MCP server processes inherited the developer’s full environment. This environment-inheritance failure makes the danger of ambient credentials concrete. The related CVE-2026-12958 covered a separate symlink-validation issue.
The MCP 2026-07-28 specification explicitly forbids forwarding an inbound client token to upstream APIs. For remote authorization, it requires OAuth 2.1 with PKCE S256, protected-resource metadata for authorization-server discovery, and resource indicators on authorization and token requests. Those rules constrain credential use at the protocol boundary. The recommended default is a dedicated OAuth app registration per server, short-lived scoped access tokens, and refresh tokens kept out of configuration files and stored in a vault.
Credential brokering removes secrets from the agent’s path. AWS documents runtime secret resolution through AgentCore Identity’s centralized credential provider. Runlayer implements built-in OAuth and credential handling with JIT credentials tied to identity through SSO and SCIM. Teams using that shared layer do not each have to build the same credential-handling machinery.
Tool-level authorization and why server-level permissions are not enough
Permission to reach a database server says little about what an agent may do there. Reading records and exporting them are different privileges. Server-level access merges those distinctions, while tool-level policy can separate reads from writes and queries from exports. Least privilege depends on that finer boundary.
An MCP server may use elevated downstream credentials on behalf of an agent whose own authorization is narrower. Without tool-level enforcement, the server effectively lends its power to the caller. The control plane must check the requested action as well as recognize the server.
Obot’s architecture ties tool permissions to identity-provider groups and uses namespaces or server groups for logical isolation. Runlayer likewise enforces policies at tool-call depth, binding identity to each action. But policy granularity creates an operational burden. Maintaining permissions across thousands of tools is impractical if teams must also register every tool manually. Uber’s registry-based model handles this by finding tools automatically while leaving the choice to enable them to their owners.
How Uber's AutoCrawler solves the registry-at-scale problem
Uber’s internal services expose APIs over HTTP, gRPC, and TChannel. Asking their owners to author and maintain MCP servers manually would make adoption slow and inconsistent. AutoCrawler removes that work from the discovery path. It uses distributed workflows subscribed to Uber’s IDL registry and internal service signals, with a scheduled cron job triggering scans for new services, APIs, and schema changes.
For each discovered entity, AutoCrawler creates or updates an MCP server representation and generates or fetches tool definitions and schemas. An LLM produces agent-friendly descriptions from extracted schemas and documentation comments. Metadata generation is automated as well as discovery. For native MCP servers without IDL-backed definitions, AutoCrawler queries the servers directly and adds them to the same registry.
Uber reports over 800 MCP servers and thousands of tools under this governance model. The scale does not depend on automatic approval. Every discovered tool enters the registry disabled, regardless of how its server was built. The owning team must review and enable it before an agent can reach it, preserving the distinction between knowing a tool exists and granting access to it.
Audit at the tool layer, not the conversation layer, and why the distinction determines compliance readiness
Conversation logs record what a model said, while tool-layer logs record its interactions with external systems. Those are different kinds of evidence. A transcript alone cannot establish which identity accessed a database, which policy permitted the action, or what outcome the call produced. The gateway’s position allows those facts to be joined at the point of execution.
AWS illustrates why observability and audit need careful distinction. AgentCore Observability provides OpenTelemetry-compatible tracing, with full tool-level spans requiring explicit enablement. CloudTrail records API activity for select AgentCore capabilities. These mechanisms work alongside each other but do not automatically form one complete record, so having both does not show that every tool call is covered.
The European Commission states that EU AI Act Article 50 transparency obligations apply from 2 August 2026. Under separate rules, high-risk system providers must keep automatically generated logs for at least six months, while financial-sector deployers must keep them in their books and records. Compliance depends on the applicable obligations.
With Runlayer,tamper-proof audit logsand full OTEL tracing operate at tool-call depth, with identity attached to actions. That makes evidence a byproduct of normal operation. Audit is the evidence layer that makes identity and authorization claims checkable.
The threat classes that the architecture must detect, not just prevent
An allowed tool call can still be malicious. Static access policy establishes permission, but it cannot by itself establish that a permitted interaction serves the agent’s task. Trail of Bits demonstrated tool poisoning that manipulated trusted tool definitions to exfiltrate a user’s chat history, including credentials, tokens, and intellectual property. The attack exploited what the tool claimed to do.
Prompt injection can also come through tool responses. Malicious instructions returned by a tool can redirect subsequent agent behavior, so inspecting request arguments alone misses the entry point. Exfiltration can also cross individually permitted actions. An agent allowed to read customer data may be manipulated into sending it to an external endpoint, making task context and behavioral inspection necessary complements to access checks.
Supply-chain vulnerabilities widen the scope beyond individual sessions. OX Security’s May 2026 disclosure covered MCP implementations in Python, TypeScript, Java, and Rust, illustrating why isolated server hardening cannot resolve a fleet-wide dependency problem. Detection needs a shared operational position. At that gateway boundary, Runlayer inspects agent-to-server calls for tool poisoning, prompt injection, intent drift, and exfiltration using the same stream that supports policy and audit. Searching separate logs later does not offer the same chance to step in.
What separates architectures that hold under fleet scale from those that collapse
Three decisions shape whether governance remains operable as a fleet grows. Enforcement can be centralized or distributed, the registry can be automated or manual, and security can share a platform or depend on separately integrated tools. Each choice assigns ongoing work to someone. Distributed authorization multiplies implementations to maintain, manual discovery lets the registry become stale, and separate security systems require a shared identity and event model to connect their findings.
Does the gateway enforce reusable tool-level rules, or does each server interpret access independently? Does the registry show what is in the fleet, with access to newly discovered tools denied by default? Can the audit record connect the user, agent, tool, authorization decision, and outcome? Does detection check live calls and responses, or does it only check logs afterward?
Runlayer is a fit for teams seeking those functions in one platform. Its documented capabilities span SSO and SCIM, JIT credentials, tool-call policies, an approved catalog of MCPs and skills, shadow MCP detection, and tool-layer audit and tracing. Its enablement layer also provides built-in credential handling and agent setup from Slack. Gusto and Instacart have standardized on it as a unified layer. That supports an integrated-platform choice, but does not establish superiority on deployment models or federation capabilities not documented here.
Obot offers another example of an architecture with shared identity, tool-level permissions, registry services, and audit. Its described use of namespaces or server groups gives teams a concrete isolation model to assess. The available information does not establish equivalent product details for TrueFoundry, Kong, IBM ContextForge, Speakeasy, Zuplo, or Bifrost (Maxim AI), so assigning them strengths, weaknesses, or rankings would overstate the record.
SSO support must be distinguished from per-user credential brokering, server access from tool-level role-based access control, and a catalog from governed server federation. Teams also need to check how well a deployment fits their needs for self-hosting, Kubernetes, cloud-native operation, or a broader LLM gateway.
Fleet governance remains an ongoing operational posture. Services change, new tools appear, and calls that are allowed can still become paths for attacks. The sustainable architecture makes discovery routine, exposure deliberate, credentials isolated, and evidence automatic. Its defining advantage is that the right behavior is the default behavior.