The protocol proliferation problem in distributed computing

The history of distributed computing is one of protocol proliferation followed by consolidation. In the late 1990s, Common Object Request Broker Architecture (CORBA), Distributed Component Object Model (DCOM), Java remote method invocation (RMI), and early Simple Object Access Protocol (SOAP) competed fiercely for the enterprise integration market. Each offered complex object-oriented abstractions and required specialized middleware, making interoperability a nightmare. Then Representational State Transfer (REST) quietly won by being simpler and HTTP-native, leveraging existing web infrastructure. Similarly, Extensible Messaging and Presence Protocol (XMPP) and Internet Relay Chat (IRC) battled for real-time messaging, but WebSockets eventually emerged as the dominant transport for bidirectional communication. This pattern of initial fragmentation followed by de facto standardization is now repeating in the AI agent space, where Model Context Protocol (MCP) has solved tool calling and Agent-to-Agent (A2A) has tackled coordination, but no consensus exists on the transport layer connecting agents across networks.

MCP and A2A: the current state of agent protocols

Model Context Protocol (MCP) has become the de facto standard for enabling AI models to call external tools and access data sources. According to industry reports, MCP is now supported by major AI platforms including OpenAI, Anthropic, and Google, with hundreds of thousands of tool integrations deployed. Agent-to-Agent (A2A) protocol, introduced by Google in early 2026, addresses coordination between multiple agents, allowing them to delegate tasks, share context, and negotiate workflows. A2A reportedly handles task decomposition, result aggregation, and error recovery across agent networks. However, both protocols assume agents are already connected via some transport mechanism—whether HTTP, WebSocket, gRPC, or proprietary channels. This leaves a critical gap: there is no standardized way for agents to discover each other, establish connections, and negotiate transport parameters dynamically. The problem mirrors the pre-REST era, where each integration required custom wiring.

The transport gap: why it matters

Without a unified transport protocol, agent systems today rely on brittle point-to-point integrations. Each agent pair must agree on a transport mechanism—HTTP/2, WebSocket, gRPC, or custom TCP—and handle connection management, authentication, rate limiting, and error handling separately. This creates a combinatorial explosion of integration work as the number of agents grows. For example, a system with 10 agents might require 45 distinct transport configurations if each pair negotiates independently. In contrast, a standardized transport layer would allow agents to discover each other via a registry, negotiate capabilities, and communicate over a common channel. The transport protocol must also handle latency, reliability, and security across heterogeneous networks, from on-premise data centers to cloud environments and edge devices. Industry observers note that the lack of such a standard is already causing fragmentation, with vendors like Microsoft, Amazon, and startup LangChain each proposing their own transport solutions.

What a transport protocol must deliver

Any candidate transport protocol for AI agents must satisfy five key requirements, according to industry experts. First, it must support dynamic discovery, allowing agents to find each other without preconfigured endpoints. Second, it must handle capability negotiation, where agents advertise their supported features (e.g., streaming, batch processing, authentication methods). Third, it must provide reliable message delivery with optional ordering and exactly-once semantics, critical for financial or healthcare applications. Fourth, it must include built-in security with end-to-end encryption and identity verification, preventing man-in-the-middle attacks. Fifth, it must be network-agnostic, working over HTTP, WebSocket, gRPC, or even message queues like Kafka. The protocol should also support both synchronous request-reply and asynchronous publish-subscribe patterns, reflecting the diverse communication needs of agent systems. A working group led by the Cloud Native Computing Foundation (CNCF) is reportedly exploring a specification called Agent Transport Protocol (ATP), though no formal proposal has been released.

The road ahead: from fragmentation to standardization

The path to a unified transport protocol will likely follow the pattern set by REST: a simple, pragmatic design that leverages existing web infrastructure will probably win over complex specifications. Just as REST used HTTP verbs and URIs to replace CORBA’s object brokers, a future transport protocol might use existing WebSocket or HTTP/3 capabilities with minimal abstraction. However, the agent ecosystem also introduces new requirements that REST never addressed, such as long-lived stateful connections, dynamic peer discovery, and decentralized identity. The industry is watching several initiatives, including the Agent Protocol Alliance (APA) formed by Anthropic, Google, and Microsoft in late 2025, which aims to propose a unified transport standard by mid-2026. Meanwhile, startups like AgentLayer and PolyAgent are building proprietary mesh networks that could become de facto standards if the open process stalls. The stakes are high: without a transport standard, the promise of interoperable AI agents—where any agent can collaborate with any other—will remain unfulfilled, and the industry may repeat the fragmentation of the 1990s.