01 article

Uber's MCP Gateway Runs 5,000 Tools Without Rewriting a Single Service

Uber's internal MCP Gateway fronts 800+ MCP servers and 5,000 tools, and the design is the API gateway pattern run again for agents: a control-plane registry where every auto-generated tool lands disabled until an owner enables it, plus incremental discovery and response projection to keep the conte

Uber's MCP Gateway Runs 5,000 Tools Without Rewriting a Single Service

Uber's MCP Gateway Runs 5,000 Tools Without Rewriting a Single Service

Uber published the design of its internal MCP Gateway in early November 2026, and the headline numbers travel fast: over 800 MCP servers, over 5,000 tools, one platform in front of all of it. But read it as an AI story and you'll miss the architecture. This is the API gateway pattern, run again against a new kind of caller. The consumer on the other side of the wire isn't a mobile app or a partner integration. It's an agent that doesn't know which service it needs until halfway through a task, and that will burn your entire context window on tool schemas if you let it. The decisions worth stealing have little to do with the Model Context Protocol itself. They're about control planes, default-deny ownership, and treating the context window as a scarce resource like bandwidth.

The problem: every team wiring their own integration

Uber runs thousands of internal services speaking HTTP, gRPC, and TChannel. When agents started showing up, teams wired their own MCP integrations to the services they cared about. That worked briefly, then produced the standard platform failure menu: duplicated infrastructure, inconsistent security controls, no discovery, tight coupling between specific agents and services. Asking every team to hand-author and maintain its own MCP server would have made the sprawl worse. The core insight corrects a common assumption: existing APIs are the fastest way to give agents tools. Not purpose-built endpoints. Not rewritten services. The contracts your services already publish, translated at the boundary.

Control plane and data plane, split cleanly

The gateway is two services, and the separation is the load-bearing decision. The MCP Registry is the control plane: a catalog of every server and tool, with schemas, ownership metadata, and an enablement flag. The Proxy Gateway is the data plane: it consumes registry configuration, materializes virtual MCP servers, and executes requests, translating MCP JSON-RPC calls into HTTP, gRPC, or Thrift/Protobuf on the way down and back into MCP results on the way up.

Two details make this operationally sane. Downstream execution goes through Muttley, Uber's service-mesh sidecar, so the gateway inherits routing, retries, and observability instead of reinventing connectivity. And the data plane refreshes its in-memory registry config on a fixed cadence, so enabling a tool or shipping a schema change takes effect without a restart. For a platform whose whole point is that owners toggle exposure at any hour, no-restart propagation is table stakes.

AutoCrawler: 5,000 tools without asking 5,000 teams

No one registered these tools by hand. AutoCrawler is a Cadence-powered distributed workflow subscribed to Uber's IDL registry. On a schedule, it scans for new services, new APIs, and schema changes. For each Protobuf or Thrift service it finds, it creates a virtual MCP server entry, parses method names and schemas out of the IDL, translates them into MCP-compatible JSON-RPC, and uses an LLM to write agent-friendly tool descriptions from the extracted documentation comments. The LLM touches only the prose. Schema translation comes from the IDL, the structural source of truth, so a model writing a nicer description can't invent a field that doesn't exist. Native MCP servers built with Uber's MCPFx framework join differently: each emits a heartbeat, AutoCrawler calls listTools, and proxies the result as a virtual server. Third-party servers like Jira and Google come through the same front door, with a separate service exchanging Uber's internal token for an external one so credential handling stays out of the core gateway.

Discovery doesn't imply exposure

This is the line in the post I'd tape above my desk. Everything AutoCrawler generates lands in the registry disabled by default. An owning team reviews the generated definition, refines it if needed, and explicitly enables it. Any change to a tool description produces a config diff the owner approves before deploy, with rollback available. Authorization runs through Uber's attribute-based access control system at server level with tool-level overrides, and the charter policies distinguish three caller types: humans, services, and agents. Responses get scrubbed for PII on the way back. Think about what that posture buys: the platform indexes thousands of services instantly because indexing is free and riskless, while exposure stays a separate, slow, human-approved step. A crawler mistake becomes a disabled row in a catalog instead of a live endpoint an agent can call. As one platform-engineering analysis put it, 5,000 tools are manageable when each has an owner and an enablement state, and 50 tools with no owners are a liability.

The context window is the new bandwidth

Scaling to hundreds of servers exposed two problems that don't exist at toy scale, both about the model's input budget.

First, discovery. MCP has no cross-server search. A client must already know a server's URL, credentials, and tool list before asking what's available. Wiring hundreds of servers into an agent would stuff the context with schemas before any work happens. Uber's answer is Omni MCP: one proxy endpoint exposing exactly four tools. discover_server finds servers from a query intent, discover_tools lists a server's tools, get_tool_schema fetches one schema, and invoke_tool runs it. The agent pages in knowledge incrementally, and the gateway's access controls apply at every step.

Second, responses. A ride-history API that returns 40 fields when the agent needs 3 is paying for 37 in tokens on every call. Response Projection injects an extra field into the tool's request schema where the agent lists the nested paths it wants, and the gateway trims the response at runtime before it reaches the model. It's GraphQL-style projection bolted onto MCP, the kind of unglamorous filter that makes an enterprise schema library survive contact with a context limit.

For coding agents there's a third trick: Code Mode, Uber's default now. The aifx command-line tool gives shell-based agents aifx mcp list, search, and call; agents chain them and write responses to files, reading back only what they need.

What the post doesn't measure

Name the gaps before copying this blindly. Uber publishes adoption numbers but no latency, availability, task-success, or cost figures, and no refresh interval or consistency model for the in-memory config. A gateway this centralized is a critical dependency by construction: when it degrades, every agent degrades. Auto-generated descriptions can still mislead an agent even when the schema is correct, which is why owner approval matters. And redaction coverage is asserted, not quantified. That doesn't make the design dubious, but it is the operators' own pitch.

Copying it at normal scale

You don't need Cadence or a service mesh to take the lessons. The registry can start as a boring spreadsheet: server, tools, owning team, enabled yes or no. Default-deny needs discipline, not a control plane: every new tool is off until someone puts their name next to it. Approving description changes is just code review pointed at your tool catalog. Progressive discovery beats loading every schema up front, and projecting responses down to the fields you use saves tokens on every call. The order matters more than the tooling: registry and ownership first, tool count second. Most teams do the opposite, wiring everything up and deferring the security review to a quarter that never arrives.

Comments