First Fortune 500 MCP at Production Scale
On October 3, 2026, eight Uber engineers including a Distinguished Engineer and Principal Engineer published a blog post detailing Uber's Model Context Protocol gateway deployment in production. The numbers: more than 800 MCP servers and 5,000 individual tools in active use, behind a single control surface.
This is the first publicly documented Fortune 500 MCP deployment at that scale, as reported by Forkast (October 3, 2026). The architecture offers a reference pattern that any enterprise with thousands of services can learn from.
Why Uber Needed a Gateway
Uber's microservice environment runs thousands of services across HTTP, gRPC, and TChannel—an internal protocol. Letting agents interact with these services ad hoc, one integration at a time, would be ungovernable at that scale. The gateway is the answer to a question every large enterprise will eventually face: how do you let agents work with production systems without losing control of what they can touch?
The Number That Matters
The headline number—5,000 tools—is what makes this deployment different from prior MCP write-ups. An agent that can call a handful of tools is a novelty. An agent that can call 5,000 tools, with discovery and authorization enforced centrally, is closer to an operating layer sitting on top of an entire enterprise.
The Dual-Plane Architecture
Uber's gateway follows a dual-plane design, as detailed in the Uber engineering blog (October 2026).
Control Plane: MCP Registry
The MCP Registry maintains a catalog of servers, tools, ownership, and enablement state. Every discovered tool starts in a disabled state and must be explicitly reviewed and enabled by the owning team before it becomes accessible to agents.
This design treats discovery as a starting point, not an authorization. The distinction matters: in an enterprise with thousands of services, the alternative—automatic enablement on discovery—would amount to giving agents unreviewed access to the entire production fleet.
Data Plane: Proxy Gateway
The Proxy Gateway forms the data plane, translating MCP protocol calls into HTTP, gRPC, or TChannel requests and routing them through Muttley, Uber's internal service mesh. The gateway exists between the agent and the production services, which is the architectural position every enterprise will eventually need to fill.
AutoCrawler: Solving Discovery at Scale
The most notable engineering decision is AutoCrawler, a Cadence-powered distributed workflow that continuously scans Uber's IDL (interface definition language) registry for new services, APIs, and schema changes. For each discovered entity, AutoCrawler uses an LLM to generate agent-friendly tool descriptions from extracted Protobuf or Thrift definitions, translates schemas into MCP-compatible JSON-RPC format, and registers the tools in a disabled-by-default state.
Why this matters: at Uber's scale, more than 10,000 service IDLs exist. Manual registration is structurally impossible. AutoCrawler eliminates the registration bottleneck without service teams needing to author an MCP server. This is the discovery-side solution other companies will need to replicate.
Omni MCP: Context-Window Management
A second extension, "Omni MCP," acts as a single proxy that exposes four tools—discover_server, discover_tools, get_tool_schema, invoke_tool—letting agents find and use tools without loading every server's full schema into context. The constraint it addresses is real: at 5,000 tools, context bloat becomes the enemy of useful agent behavior.
Response Projection
A third extension applies a GraphQL-like field selection pattern to MCP tool responses, trimming the payload to only the fields the agent actually needs. With thousands of tools returning structured responses in JSON-RPC, response-token bloat becomes a cost and latency constraint that breaks uncontrolled deployments.
Together, AutoCrawler, Omni MCP, and Response Projection attack the two scaling constraints that break enterprise MCP: context-window exhaustion and response-token bloat.
Security: Actor Chains, Short-Lived Tokens, Charter Policies
The security architecture, detailed in a separate Uber engineering blog post from May 2026, anchors the gateway to an AI Agent Mesh and a Security Token Service that issues short-lived, single-hop JWT tokens with full actor chain propagation.
The actor chain is the architectural feature other enterprises should be paying closest attention to. Every agent action carries a verifiable lineage, from the originating user through each intermediate agent to the final tool invocation. With P99 latency under 40 milliseconds for token exchange, this is a security primitive that does not slow the system down.
The gateway also enforces charter policies at the tool level, applies PII redaction automatically, and tiers access between first-party and third-party MCP servers. Uber's 2026 roadmap adds dynamic access control and a unified policy enforcement plane, signaling a move toward more granular, session-aware authorization.
Why This Matters for Any Enterprise Considering MCP
Three architectural observations generalize beyond Uber.
Discovery Beats Manual Registration at Scale
Teams building MCP deployments without an AutoCrawler-style automated discovery layer will hit a ceiling. If your internal service count is in the hundreds, manual registration is feasible. At Uber's scale, it is not. The architectural commitment to an automated discovery sidecar, with LLM-generated tool descriptions, is a pattern worth replicating.
Context Bloat Is a Real, Not Theoretical, Constraint
A growing number of articles have suggested MCP at scale will "just work." Uber's production deployment shows it doesn't. Omni MCP and Response Projection are deliberate engineering responses to context exhaustion and response bloat. Plan for both layers from the start.
Governance Goes Per-Tool, Not Per-Server
Disabled-by-default is the only honest starting position at scale. The pattern makes every tool a deliberate enrollment, not a default accessibility. Pair this with actor-chain lineage and you have a security model that aligns with how production access controls work in enterprise environments.
For teams evaluating MCP infrastructure, our Wiz MCP security layer analysis covers a complementary pattern from outside the Uber deployment. Both Uber's gateway and the Wiz architecture end up at the same place: per-tool policy, lineage, and tier-proxying as the security core.
For more on running AI agents safely inside enterprise compute, our OpenAI Dots always-on agents coverage sets the broader context, and the Blueprint Alliance between Okta, AWS, and Google Cloud makes the case for shared standards across provider boundaries.
For enterprises designing agent infrastructure that needs this kind of governed, production-grade MCP architecture, contact Vivid to discuss integration patterns and reference architecture.
Read Next
- Google's Critical Mandate: Manual Fact-Checking for All AI Content Is Now Non-Negotiable
- Yext's Multiplayer Agent Harness: Marketing Teams Enter Multi-Agent Operations
- Oracle Fusion Claw: The Governed Runtime Turning AI Assistants into Enterprise Executors
- Wiz's MCP Agent Integrations: The AI Security Layer
