The evolution of distributed computing has historically followed a pattern: a period of protocol divergence, eventually leading to a phase of consolidation. Early enterprise integration efforts saw a proliferation of competing standards like CORBA, DCOM, RMI, and initial SOAP versions. Ultimately, REST emerged victorious due to its simplicity and native integration with HTTP. Similarly, real-time messaging experienced fragmentation with protocols such as XMPP and IRC, before MQTT and WebSockets established dominant niches. This trend suggests that new computing paradigms invariably spur an initial wave of competing standards, which then gradually converge as implementations mature and the economic imperative for interoperability grows.
The current AI agent ecosystem is decidedly in this proliferation phase. Over the past eighteen months, four significant protocols have been introduced: Anthropic’s Model Context Protocol (MCP) in late 2024, IBM Research’s Agent Communication Protocol (ACP) in March 2025, Google’s Agent2Agent (A2A) in April 2025, and an independent working group’s Agent Network Protocol (ANP). Standardization efforts are also underway, with the W3C AI Agent Protocol Community Group initiating a standards track and the Internet Engineering Task Force (IETF) receiving Internet-Drafts related to agent transport. Industry conferences are hosting workshops on interoperability, and new GitHub repositories addressing agent communication challenges appear weekly.
Understanding the trajectory and speed of this convergence is crucial for making informed architectural decisions today.
What the Protocols Actually Address
While the proliferation might seem chaotic, these protocols often address different layers of a communication stack, rather than directly competing for the same functionality. The confusion typically stems from marketing, where each is presented as “the standard for AI agent communication” without specifying the precise aspect of communication they standardize.
- MCP (Model Context Protocol): This is a tool-calling interface. It defines how an AI model discovers and invokes functions exposed by a server, and how to interpret the responses. It essentially acts as a typed Remote Procedure Call (RPC) contract between a model client and a tool server, operating over HTTP. By April 2026, MCP had garnered significant traction, with over 10,000 public MCP servers and 164 million monthly Python SDK downloads, indicating its establishment as the de facto standard for tool-calling.
- A2A (Agent2Agent): This protocol focuses on task coordination. While MCP handles agent-to-tool invocation, A2A specifies how two agents can delegate tasks to each other. It introduces concepts like Agent Cards (for capability advertisements), defined task lifecycle states, and three interaction modes: synchronous, streaming, and asynchronous. Google’s donation of A2A to the Linux Foundation in June 2025 has led to its widespread adoption by enterprise AI teams, as it addresses a critical gap left by MCP.
- ACP (Agent Communication Protocol): ACP is an efficient message envelope format. Designed to be lightweight and stateless, it facilitates agent-to-agent message exchange without the full coordination semantics of A2A. It is particularly useful in systems where simple message passing is sufficient and the overhead of A2A’s task lifecycle management is not required.
- ANP (Agent Network Protocol): This protocol serves as a discovery and identity layer. It utilizes Decentralized Identifiers (DIDs) for agent identity and JSON-LD graphs for capability descriptions, laying the groundwork for decentralized agent marketplaces that do not rely on a central registry.
The emerging communication stack appears to be ANP for capability discovery (or simpler registry mechanisms), A2A for task coordination, MCP for tool calls, and ACP for lightweight messaging in scenarios not requiring comprehensive task lifecycle management. These layers are designed to be complementary rather than competitive.
The Unresolved Transport Challenge
A common thread among these protocols is their reliance on HTTP. This is largely a reflection of their origins, stemming from research teams, API providers, and enterprise software companies accustomed to HTTP as a foundational technology, making it convenient for demonstrations and leveraging existing infrastructure.
However, HTTP presents a significant challenge in production environments: it assumes server reachability. For the vast majority of networked devices (88%) operating behind Network Address Translation (NAT), direct server reachability is not possible without a relay mechanism. This forces agent fleets that need to route tasks directly between peers across different network boundaries (cloud, home, edge) to route all messages through centralized relay infrastructure. Such relays introduce latency, increase costs, and create single points of failure.
While the application-layer protocols define the semantics of inter-agent communication, they do not address the fundamental issue of how agents discover and establish direct connections. This is a session-layer problem (Layer 5 in the OSI model), and none of MCP, A2A, ACP, or ANP directly tackle it.
Solutions to this challenge do exist. Techniques such as UDP hole-punching combined with Session Traversal Utilities for NAT (STUN) can achieve NAT traversal in approximately 70% of network topologies. Cryptographic methods like X25519 Diffie-Hellman and AES-256-GCM provide authenticated encryption at the tunnel level without requiring a Certificate Authority. Protocols like QUIC (RFC 9000) or custom sliding-window protocols over UDP offer reliable delivery without the head-of-line blocking inherent in TCP. These are the same building blocks used in technologies like WireGuard VPNs and WebRTC for browser-to-browser media streaming.
The unique aspect in the agent context is capability-based routing. Agents need to locate peers not by their network address but by their functional capabilities. An agent designed for financial data analysis, for instance, should be able to query the network for other agents possessing real-time foreign exchange data. This is akin to a service registry and represents a natural extension of ANP’s design principles applied to the transport layer.
Several projects are actively assembling these components. The Pilot Protocol project has developed a comprehensive specification, including an IETF Internet-Draft covering addressing, tunnel establishment, and NAT traversal for agent networks. The libp2p framework offers a robust foundation with similar primitives. Furthermore, the IETF’s QUIC working group is developing NAT traversal extensions that will be highly relevant to this problem space.
Projected Convergence Landscape
The HTTP-based application-layer protocols, MCP and A2A, are already converging towards stable versions. The next twelve months are expected to focus on production hardening, security enhancements, the development of stateless MCP servers for improved scalability, and more robust A2A federation, rather than fundamental design shifts. The layers dealing with tool-calling and task coordination are largely considered resolved.
The transport layer, however, lags behind by approximately 18 to 24 months. A period of diverse implementation approaches to peer-to-peer (P2P) agent networking is anticipated. Consolidation will likely occur around a few implementations once empirical data on performance and reliability becomes available. Formal standardization through the IETF and W3C is projected for the 2027-2028 timeframe, by which point one or two open-source implementations will likely have achieved de facto standard status through widespread production adoption.
For engineering leaders making architectural decisions now, a layered adoption strategy is advisable. The application-layer protocols are sufficiently stable for building upon; adopting MCP carries minimal risk. A2A adoption for multi-agent coordination is feasible, with the understanding that the protocol may still evolve. The transport layer presents a choice: either develop custom solutions with the expectation of future replacement or evaluate early implementations while acknowledging the dynamic nature of this domain.
Organizations that prioritize a clear separation between application semantics (MCP, A2A) and the transport layer will be best positioned to adapt as the transport layer matures. This clean architectural separation is relatively inexpensive to implement now and prohibitively costly to retrofit later, a crucial lesson learned from the microservices era regarding observability and resilience.
Philip Stayetski is a co-founder of Vulture Labs.
Welcome to the VentureBeat community!
Our guest posting program is where technical experts share insights and provide neutral, non-vested deep dives on AI, data infrastructure, cybersecurity and other cutting-edge technologies shaping the future of enterprise.
Read more from our guest post program — and check out our guidelines if you’re interested in contributing an article of your own!
Business Style Takeaway: The AI agent ecosystem is rapidly standardizing at the application layer (tool calling, task coordination), offering immediate opportunities for integration. However, the underlying peer-to-peer transport layer remains nascent, necessitating strategic architectural choices that prioritize clean separation between semantics and transport to mitigate future integration challenges and costs.
Learn more at : venturebeat.com