Uber MCP Gateway and Omni MCP Incremental Discovery at 800 Servers

Uber’s engineering organization published one of the clearest enterprise case studies yet for Model Context Protocol adoption: an internal MCP Gateway hosting more than eight hundred MCP servers and five thousand tools, with a single orchestration layer handling discovery, authorization, protocol translation, and execution. InfoQ and industry blogs picked up the story on November 2, 2026, but the architecture described in Uber’s October engineering post reflects months of production hardening—not a lab demo.

The problem Uber solved is familiar to any company that tried wiring one chatbot to dozens of internal APIs. Each team exposing MCP servers duplicated authentication, logging, and schema maintenance. Agents configured with full tool lists blew context windows before reading user prompts. Security teams lacked consistent charter policies per tool. MCP Gateway centralizes those concerns so existing REST and gRPC services can become MCP tools without every squad rebuilding infrastructure.

Omni MCP and incremental discovery

MCP has no native cross-server search. Traditionally, clients must know a server URL, load credentials, and prefetch entire tool catalogs—untenable at eight hundred servers. Uber’s Omni MCP proxy exposes four meta-tools: discover_server (intent-based server lookup), discover_tools (list tools for a chosen server), get_tool_schema (fetch one JSON schema), and invoke_tool (execute). Agents traverse the catalog lazily, loading only the schema they need for the current step.

That pattern attacks context-window exhaustion, the silent killer of enterprise agents. An employee asking to refund a ride should not inject five thousand tool definitions into the prompt. Instead, the agent discovers a payments server, lists refund-related tools, pulls one schema, and calls it—mirroring how humans navigate internal wikis rather than memorizing every API endpoint.

Uber pairs Omni MCP with Response Projection, a GraphQL-like field selection mechanism trimming tool outputs to requested columns. Large JSON blobs from legacy services shrink before returning to the model, saving output tokens and reducing hallucination surface. For coding agents, Uber’s aifx CLI writes tool results to files so shell-based workflows inspect payloads selectively instead of dumping megabytes into chat.

Governance at scale

Volume without governance is liability. Uber states every MCP server and tool starts disabled until owning teams review and enable it—separate from runtime permission checks. The gateway integrates with internal access control, applying charter policies per server and per-tool overrides depending on whether the caller is human, service account, or autonomous agent. Authorization and PII redaction happen on the request path; teams must still decide whether discovery endpoints filter disabled or unauthorized tools before agents see them—a design detail implementers should not leave ambiguous.

For software-development leaders, the lesson is organizational: MCP Gateway is as much a product-management platform as a protocol router. Tool owners become publishers; security becomes approver; agent builders become consumers with a stable Omni interface.

Comparison to ad hoc integrations

Before MCP, Uber teams likely built bespoke function-calling wrappers per agent vendor. MCP standardizes schemas and invocation, letting the same refund tool serve Claude-based support bots and internal codegen agents. The gateway translates protocols where backends are not natively MCP, avoiding rewrites of stable microservices.

Challenges remain. Latency stacks across discovery hops. Version skew between tool schema and backend deployment can cause silent failures unless CI enforces contract tests. Observability must trace discover_server calls through invoke_tool to root-cause misconfigured policies.

Implications for your roadmap

If you operate more than a few dozen internal APIs and plan autonomous agents, copying Uber’s layered approach beats connecting ChatGPT to Swagger files ad hoc. Start with a gateway skeleton, mandatory tool registration, default-disabled posture, and incremental discovery before you expose finance or HR tools. Omni MCP’s four meta-tools are a reusable pattern even outside Uber’s codebase—implement intent search via embeddings or keyword indexes over server metadata.

Uber’s scale—eight hundred servers, five thousand tools—sets an upper bound reference. Smaller companies benefit from the same architecture with lighter policy engines. The November 2026 news cycle simply confirmed the design survived production traffic, not that MCP replaces workflow engines. Step Functions, Temporal, and BPM tools still own long-running processes; MCP excels at granular capability access.

Closing perspective

Uber MCP Gateway plus Omni MCP incremental discovery is a blueprint for token-efficient, governable agent tooling. Developers reading the post should extract principles: centralized registration, lazy schema loading, response projection, and caller-aware authorization. Whether you build on Anthropic’s MCP spec or future successors, the bottleneck moved from “can the model call APIs?” to “can we expose APIs without drowning the model in metadata?” Uber answered that at fleet scale.

Implementation sketch for mid-size teams

You may not need eight hundred servers on day one. Start with a registry database, authenticated MCP proxy, and four Omni-style meta-tools implemented over your catalog. Index server descriptions with embeddings; enforce OAuth scopes per tool; log every invoke_tool with caller identity. Add Response Projection when legacy APIs return ten-kilobyte JSON blobs for simple queries.

Failure modes to document

Discovery hallucination—agents picking wrong servers—requires feedback loops and human escalation paths. Schema drift breaks invoke_tool silently unless contract tests run in CI. Policy misconfiguration exposes finance tools to demo agents; default-disabled posture plus explicit enablement workflows mitigates accidents Uber learned the hard way at scale.

Relationship to API gateways

Traditional API gateways handle rate limits and auth; MCP Gateway adds schema semantics models understand. Consider Kong or Apigee coexisting with MCP layers rather than replacing them. Translate OpenAPI to MCP tools incrementally, prioritizing read-only endpoints before destructive writes.

Developer experience wins

Internal developer satisfaction rises when codegen agents reliably file tickets, query metrics, and restart staging services without bespoke integrations per IDE. Uber’s aifx CLI pattern—write tool output to files—helps JetBrains and VS Code agents alike. Developer marketing at other enterprises can cite Uber as reference architecture without claiming feature parity.

Metrics Uber likely tracks

Server enablement rates, discover_server miss rates, invoke_tool error codes, and policy denial counts form the internal scorecard. External teams should define similar KPIs before declaring MCP programs successful. Vanity metrics like total registered tools mislead if most stay disabled.

Open-source opportunity

Uber has not open-sourced Gateway wholesale, but Omni MCP’s pattern is reimplementable. Vendors selling MCP management startups will cite Uber; enterprises should evaluate build versus buy against headcount reality.

Cost of context saved

Incremental discovery reduces token bills materially at five-thousand-tool scale—finance teams should model savings when pitching MCP Gateway internally. A back-of-envelope estimate: loading full schemas might cost tens of dollars per session on frontier models; lazy discovery cuts that by orders of magnitude for narrow tasks.

Human-in-the-loop for destructive tools

Even with gateway policies, require human approval workflows for tools that transfer money, delete data, or modify production configs. Omni MCP does not replace SOX controls—it exposes capabilities models should not wield unsupervised.

Conference talk outline

A fifty-minute conference narrative: ten minutes on MCP fragmentation pain, fifteen on Gateway architecture, fifteen live demo of discover_server through invoke_tool on three servers, ten on policy lessons. Uber’s November 2026 press cycle gives external speakers citation material without claiming production parity.

Platform engineering leaders outside Uber should prototype Omni-style discovery before registering their hundredth MCP server. The cost of context stuffing is invisible until agents fail in production; incremental discovery makes the tax visible and manageable. Treat gateway policy as product surface area, not security afterthought.