AI agents are moving into production environments. They need to connect with enterprise tools and systems to get work done. The Model Context Protocol (MCP) handles this communication. But there’s a gap.
MCP uses JSON-RPC as its standard transport. Most enterprises, however, run on gRPC. This creates friction. Organizations need transcoding gateways to translate between the two protocols. It adds complexity and cost.
Google Cloud wants to fix this. The company announced it’s working with the MCP community to support gRPC as a native transport option.
The Problem With Transcoding
If an enterprise already uses gRPC across its infrastructure, adding MCP requires a full infrastructure-wide adaptation. Teams must deploy transcoding gateways. These gateways sit between MCP requests and existing gRPC services, translating between them.
This works, but it’s inefficient. It adds latency. It creates another point of failure. And it requires maintenance.
Stefan Särne, Senior Staff Engineer at Spotify, explained his company’s approach: “Because gRPC is our standard protocol in the backend, we have invested in experimental support for MCP over gRPC internally. And we already see the benefits: ease of use and familiarity for our developers and reducing the work needed to build MCP servers by using the structure and statically typed APIs.”
Spotify isn’t alone. Many organizations with mature gRPC deployments face the same challenge.
Why gRPC Makes Sense
gRPC offers specific advantages for agent-to-tool communication.
Performance gains are substantial. gRPC uses protocol buffers for binary encoding. This shrinks message sizes by up to 10x compared to JSON. Lower bandwidth means faster response times and lower network costs.
The protocol supports full-duplex bidirectional streaming. Both the agent and the tool can send continuous data streams simultaneously over one connection. This enables real-time workflows without complex synchronization.
Built-in flow control prevents fast-sending tools from overwhelming agents. The framework handles backpressure automatically.
Security features are enterprise-grade. Mutual TLS (mTLS) authenticates both client and server. This is critical for zero-trust architectures. It prevents spoofing and ensures only trusted services communicate.
gRPC integrates with standard token-based authentication protocols, including JWT and OAuth. Every agent gets a verifiable identity.
Method-level authorization lets you control access at a granular level. An agent might have permission to read a file but not delete it. This enforces least privilege and reduces risk.
Operational benefits improve reliability. Native integration with OpenTelemetry provides distributed tracing. You can follow a single user prompt through every subsequent service interaction.
Deadlines and timeouts prevent unresponsive tools from causing system failures. If a tool call exceeds its deadline, the framework automatically cancels it.
Error handling is standardized. The framework provides consistent error codes, such as UNAVAILABLE and PERMISSION_DENIED. Clients can handle failures reliably.
“Adding gRPC as a native transport for MCP is about removing friction between agent frameworks and the infrastructure enterprises already trust in production. When MCP traffic can ride the same multiplexed, streaming, backpressure-aware fabric as existing services, agent-to-tool interactions become faster, more predictable, and easier to operate at scale. That matters once agents move from occasional calls into sustained, high-QPS, streaming-heavy workloads,” according to Mitch Ashley, VP and Practice Lead Software Lifecycle Engineering, The Futurum Group.
“At a system level, this signals MCP maturing from a developer-friendly integration layer into a production-grade control plane for agent work. Transport pluggability lets JSON-RPC semantics stay stable while enterprises standardize on the operational properties they require for security, observability, and reliability. gRPC support does not change what MCP is, but it materially improves how safely and efficiently agents can be trusted to act inside real enterprise environments.”
What Happens Next
Google Cloud is a founding member of the Agentic AI Foundation and contributes to the MCP specification. The company is working with core maintainers to add pluggable transport support to the MCP SDK.
MCP maintainers have agreed to support this approach. Google Cloud will contribute and distribute a gRPC transport package that plugs into MCP SDKs.
A community-backed transport package ensures gRPC users can deploy MCP consistently. No custom implementations. No compatibility issues.
The work is already underway. Developers can contribute to the active pull request for pluggable transport interfaces in the Python MCP SDK.
Developer Impact
For development teams, gRPC support means less retrofitting. If your infrastructure already runs on gRPC, you can add MCP without rebuilding your services.
gRPC generates code for more than 11 languages. Teams can implement MCP servers in whatever language fits their use case. The strongly typed contract stays consistent.
Protobuf’s strict typing validates inputs at the serialization layer. This catches malformed requests early and helps prevent injection attacks.
The Bigger Picture
AI agents need reliable connections to enterprise tools. MCP provides the standard. But the standard needs to work with existing infrastructure.
Adding gRPC support removes a barrier. Organizations won’t need to choose between MCP adoption and their current tooling. They can have both.
Google Cloud’s commitment matters. The company uses gRPC extensively across its global operations. That experience will inform how gRPC transport gets implemented.
For enterprises evaluating AI agent deployments, gRPC support for MCP means one less integration hurdle. The path to production gets clearer.
