Uber Unifies AI Agent Calls with a Single MCP Gateway

Uber uses an MCP gateway to unify heterogeneous backends so AI apps learn only one protocol.
The Uber engineering team shared an MCP gateway solution for fragmented backend tech stacks when AI apps call external capabilities. Callers like Cursor, Cloud Code, and internal deep agents all send requests via MCP over JSON RPC 2.0. The gateway handles routing, security validation, and protocol translation, branching by target type: Thrift for TChannel, HTTP/JSON for REST, Proto for gRPC, and direct passthrough for native MCP. The essence is pushing protocol adaptation down to the gateway layer, so callers master one protocol, backend differences are absorbed, and security and auditing are centralized.
When AI applications need to call external capabilities, they often face a real-world problem: backend services use a wide variety of tech stacks—Thrift, REST, gRPC, and native MCP services. If every caller has to adapt to each one individually, engineering costs balloon quickly. Uber's approach is to introduce an MCP gateway that funnels all heterogeneous calls into a single entry point.
One Protocol Entry Point, Abstracting Away Backend Differences
According to content shared by the Uber engineering team on YouTube, MCP (Model Context Protocol) is a standard way for AI applications to discover external capabilities and communicate with them. At Uber, callers include Cursor, Cloud Code, internal deep agents, and any generic MCP client.

These callers don't need to know what tech stack the backend uses. They all send MCP requests via JSON RPC 2.0 to a single place—the MCP gateway. The gateway handles routing, security validation, and protocol translation, delivering requests to the services that actually provide the capabilities.

The core value of this design is that "callers only need to learn one protocol." AI applications don't need to write one adapter for Thrift and another for gRPC—the gateway absorbs the complexity.
MCP (Model Context Protocol) is an open protocol proposed and open-sourced by Anthropic in late 2024, aiming to define a unified interaction contract between AI applications and external tools and data sources. It borrows the idea of the Language Server Protocol (LSP): decoupling "capability providers" from "capability consumers," with the protocol specifying how to discover tools (tools/list), how to call tools (tools/call), how to read resources (resources), and how to use prompt templates (prompts). At the transport layer, MCP supports stdio and HTTP-based streaming, with message bodies encoded in JSON-RPC 2.0.
JSON-RPC 2.0 is a lightweight remote procedure call protocol that specifies that requests must contain jsonrpc, method, params, and id fields, while responses fall into two categories: result and error. It is not tied to any transport method—HTTP, WebSocket, and stdio can all carry it—making it well suited as a unified message format for the front and back ends of a gateway: callers and the gateway only need to agree on method names and parameter structures.
How the Gateway Performs Protocol Translation
The gateway's routing logic branches based on the type of target service, so the same MCP request can be translated into four different backend call styles.
Thrift Services
For T-channel services, the gateway initiates calls using T-channel with the Thrift protocol.

Thrift is a cross-language RPC framework open-sourced by Facebook and later donated to Apache. It describes service methods via IDL (Interface Definition Language), from which a compiler generates multi-language client and server code. It supports a variety of transport and protocol combinations, among which TChannel is an RPC protocol led by Uber. Based on TCP multiplexing, it supports request/response framing, timeout propagation, and trace context propagation, making it an important piece of infrastructure for Uber's internal service-to-service communication. The so-called "T-channel service" refers to these existing services that use TChannel as the transport layer and Thrift as the serialization protocol. The gateway must initiate calls in TChannel's frame format rather than simply sending an HTTP request.
REST Backends
REST backends are accessed via HTTP and JSON—the most common type of service.
gRPC Services
For gRPC services, the gateway makes calls using gRPC with Proto.

gRPC is a high-performance RPC framework open-sourced by Google, using Protocol Buffers (Proto) by default as the interface definition and serialization format: developers first write .proto files defining messages and services, then protoc generates stub code for each language. gRPC runs on top of HTTP/2 and natively supports streaming calls, header compression, and multiplexing. For the gateway, translating an MCP request into a gRPC call mainly involves mapping JSON parameters to Proto message fields and initiating unary or stream calls using the method names defined in the .proto file; Proto's strong typing also allows some parameter validation to be pushed forward into the gateway.
Native MCP Services
If the target is itself a native MCP server, the gateway simply forwards MCP over JSON RPC 2.0 to it without any translation.
The essence of this branching is to push "protocol adaptation" down from every caller into a single gateway layer. The more callers there are and the more diverse the backend tech stacks, the more pronounced the benefits of this convergence.
Why This Pattern Is Worth Attention
MCP is becoming the de facto standard for AI applications to connect to external tools, but standards solve "how to say it," not "how to reach it." Real enterprise services often accumulate over many years and cannot all be rewritten just for AI calls.
Uber's gateway solution provides the answer: add a translation and governance layer between the standard protocol and existing services. Security validation and routing policies are centralized in this layer, making them easier to maintain and audit uniformly than scattering them across individual callers.
For teams building AI Agent infrastructure, this idea has direct reference value—there's no need to force backend uniformity; instead, make the entry point uniform.
When discussing gateway solutions, it's important to distinguish the responsibilities of a "gateway" from those of a "proxy." A pure proxy only forwards requests, while an MCP gateway additionally takes on three things: first, protocol translation, mapping unified MCP semantics to the specific call forms of each backend; second, capability aggregation, consolidating tools scattered across multiple backend services into a single tool list visible to AI applications, so callers don't have to assemble it themselves; and third, governance, including authentication, rate limiting, audit logs, and permission boundary control. This also explains why security validation is more reasonably placed at the gateway layer than at the caller: AI application call paths are often dynamically determined by the model, and only by centralizing policies at the gateway can a unified and auditable boundary be formed.
Key Takeaways
- The MCP gateway gives Cursor, Cloud Code, internal deep agents, and generic MCP clients a shared call entry point
- Callers only need to understand MCP over JSON RPC 2.0; backend differences are absorbed by the gateway
- The gateway branches by target type: Thrift, HTTP/JSON, gRPC/Proto, and native MCP
- Security validation and protocol translation are centralized at the gateway layer, facilitating unified governance
One-line Summary
Uber uses an MCP gateway to unify heterogeneous backends, so AI applications only need to learn one protocol.
Paragraph Summary
The Uber engineering team shared an MCP gateway solution that addresses the problem of fragmented backend tech stacks when AI applications call external capabilities. Callers—including Cursor, Cloud Code, internal deep agents, and generic MCP clients—all send requests to the gateway via MCP over JSON RPC 2.0. The gateway takes on three responsibilities: routing, security validation, and protocol translation, branching by target service type: TChannel services are called via Thrift, REST backends via HTTP/JSON, gRPC services via Proto, and native MCP servers are passed through directly. The essence of this design is to push protocol adaptation down from every caller into a single gateway layer, so callers only need to master one protocol, backend differences are fully absorbed, and security policies and auditing are centrally managed.
Related articles

Anthropic's IPO Eve: Five Risks Behind the Trillion-Dollar Valuation and the Truth About Its Governance
Breaking down Anthropic's IPO prospectus: $184M daily revenue at a trillion-dollar valuation, the truth behind $104B in paper losses, a five-class share governance structure, unusual disclosures in 94 pages of risk factors, and how the lock-up schedule may affect retail investors.

FBI Warns: Hackers Weaponize AI Agent ARTEX to Attack 200+ Organizations
FBI warns that AI penetration framework ARTEX is being used to attack 200+ organizations, with CrowdStrike tracking the VaporPanda group. We break down ARTEX's agent orchestration architecture, the real attack chain, loss data, and the FBI's five defense recommendations.

FBI Warns: Free AI Hacking Tool Artex Spirals Out of Control, Breaches Cloud Systems in Three Hours
FBI warns that the free open-source AI penetration tool Artex is being abused by criminals and state-backed hackers to breach cloud systems in as little as three hours. This article analyzes real attack cases, overlooked side-door risks, and defense measures enterprises and individuals can take immediately.