Agent-to-Agent Communication Protocol Standards: A2A, MCP, ACP, and ANP

Executive Summary

The AI agent ecosystem in 2025-2026 is converging on four complementary interoperability protocols: A2A (Agent-to-Agent) from Google, MCP (Model Context Protocol) from Anthropic, ACP (Agent Communication Protocol) from IBM, and ANP (Agent Network Protocol) from the community. Rather than competing, these protocols address different layers of agent communication — from tool access (MCP) to enterprise collaboration (A2A) to decentralized marketplaces (ANP). Google's A2A, donated to the Linux Foundation in June 2025 with 50+ partners including AWS, Microsoft, Salesforce, and SAP, has emerged as the leading standard for agent-to-agent collaboration. The industry consensus points toward multi-protocol coexistence, analogous to how HTTP, WebSocket, and gRPC coexist in modern web infrastructure.

The Four Protocols at a Glance

Feature	MCP	ACP	A2A	ANP
Origin	Anthropic (Nov 2024)	IBM (2024)	Google (Apr 2025)	Community (2024-2025)
Governance	Linux Foundation	Linux Foundation	Linux Foundation	Community
Architecture	Client-Server	Brokered	Peer-like	P2P Decentralized
Message Format	JSON-RPC 2.0	Multipart MIME	JSON-RPC 2.0	JSON-LD
Discovery	Manual/Static	Registry	Agent Card	DID + .well-known
Transport	HTTP	HTTP/REST	HTTP, gRPC, SSE	HTTPS
Target Use Case	LLM-Tool Integration	Multi-Framework	Enterprise Agent Collaboration	Decentralized Marketplaces
Primary Strength	Tight LLM integration	Multimodal messaging	Inter-agent negotiation	Trustless identity

Google's A2A Protocol

The Agent2Agent (A2A) Protocol is the most significant entrant, enabling AI agents from different providers to discover, authenticate, and collaborate without exposing internal implementation details.

Core Architecture

A2A operates on three layers:

Data Model (protocol-agnostic): Task, Message, AgentCard, Part, Artifact, Extension objects
Operations (binding-independent): Send Message, Stream, Get/List/Cancel Task, Subscribe
Protocol Bindings: JSON-RPC 2.0 over HTTPS (primary), gRPC with Protocol Buffers, HTTP/REST

The key design principle is opacity — agents collaborate based on declared capabilities without exposing internal reasoning, plans, or tool implementations.

Agent Card Discovery

The Agent Card is A2A's discovery mechanism — a JSON document serving as a digital business card:

{
  "name": "Inventory Agent",
  "description": "Manages product inventory and stock levels",
  "url": "https://agent.example.com/",
  "version": "1.0.0",
  "capabilities": {
    "streaming": true,
    "pushNotifications": false
  },
  "skills": [
    {
      "id": "check_stock",
      "name": "Check Stock Levels",
      "description": "Query current inventory for any product",
      "tags": ["inventory", "stock"],
      "examples": ["Check stock for SKU-12345"]
    }
  ],
  "securitySchemes": {
    "oauth2": {
      "type": "oauth2",
      "flows": {
        "clientCredentials": {
          "tokenUrl": "https://auth.example.com/token"
        }
      }
    }
  },
  "defaultInputModes": ["text/plain"],
  "defaultOutputModes": ["text/plain", "application/json"]
}

Discovery strategies include well-known URIs (/.well-known/agent-card.json), registry-based lookup, and direct configuration.

Task Lifecycle

Tasks progress through defined states: submitted -> working -> completed/failed/canceled. Notably, tasks can also enter input_required or auth_required states for multi-turn interactions. Terminal states are final — subsequent work requires a new task within the same contextId.

Streaming and Real-Time Updates

A2A provides three delivery mechanisms:

Polling: Client calls GetTask periodically (simplest, highest latency)
Server-Sent Events (SSE): Persistent connection with real-time event delivery
Push Notifications: HTTP POST to registered webhooks for disconnected clients

SDK Ecosystem

Official SDKs are available for Python (pip install a2a-sdk), JavaScript/TypeScript (npm install @a2a-js/sdk), Go, Java, and .NET. The GitHub repository has 21.9k stars.

MCP: The Tool Integration Layer

Anthropic's Model Context Protocol, launched November 2024, standardizes how AI agents interact with tools, databases, and APIs. It became a de facto standard within a year.

MCP uses a hierarchical client-server design where the Host application initiates interactions with MCP Servers that provide context and capabilities. It's optimized for single-agent systems needing tool access — think of it as the "USB-C of AI" for connecting models to external resources.

Key distinction from A2A: MCP handles the vertical connection between an LLM and its tools, while A2A handles horizontal communication between peer agents.

ACP: Infrastructure-Level Communication

IBM's Agent Communication Protocol uses a brokered architecture with three roles: Agent Clients, ACP Servers (registries), and ACP Agents. Its REST-native messaging with multipart MIME supports multimodal responses, making it well-suited for cross-framework interoperability where agents built with LangChain, CrewAI, or custom code need to collaborate.

ANP: Decentralized Agent Networks

The Agent Network Protocol takes the most distributed approach, leveraging W3C Decentralized Identifiers (DIDs) and JSON-LD for agent identity and capability description. Agents publish metadata without centralized registries, enabling open-internet agent marketplaces with trustless authentication through cryptographic credentials.

WebSocket vs HTTP for Agent Communication

This comparison is particularly relevant for projects like BotsHub that chose WebSocket transport:

Why WebSocket Wins for Agent Messaging

Industry experience — notably from Liveblocks' engineering team — demonstrates that HTTP's request-response model struggles with agent workflows:

Persistent connection: Server pushes updates without polling
State consistency: Updates broadcast to all connected clients automatically
Lower latency: No repeated HTTP handshakes
Bidirectional: Both sides can initiate messages
Resilience: Connection survives across page refreshes and tab switches

The Hybrid Approach

The recommended architecture uses both:

HTTP for: APIs, synchronous operations, Agent Card discovery, logs
WebSocket for: Real-time collaboration, long-running task updates, multi-device sync

A2A itself supports this hybrid model — JSON-RPC over HTTP for standard operations, SSE for streaming, and gRPC for high-performance scenarios.

Security Considerations

Authentication Landscape

Protocol	Primary Auth	Additional
MCP	OAuth 2.1 + PKCE	Schema validation, digital signatures
ACP	Bearer tokens, mTLS	Signed manifests, JWS
A2A	OAuth 2.0, mTLS, API Key, OIDC	Signed Agent Cards, scoped tokens
ANP	DID signatures	HTTPS-hosted DIDs

Best Practices

Never embed secrets in JSON-RPC payloads
Use OAuth 2.0 for user-delegated access
Implement mTLS for high-security environments
Validate Agent Card signatures before trusting capabilities
Log all interactions for audit trails
Enforce least-privilege authorization

Real-World Adoption

Major Adopters

A2A launched with 50+ partners. Notable implementations:

Salesforce: Agentforce agents using A2A for cross-ecosystem collaboration
ServiceNow: A2A + MCP enabled for Now Assist AI Agents (Zurich Patch 4)
AgentMaster (Stanford + George Mason): First system integrating both A2A and MCP

Market Trajectory

35% of AI-focused enterprises actively exploring A2A integration
65-75% year-over-year growth projected through 2026
$2.3 billion market valuation projected by 2026

The Multi-Protocol Future

The industry is converging on a layered adoption strategy:

Phase 1: MCP for foundational tool access
Phase 2: ACP for multi-framework interoperability
Phase 3: A2A for enterprise agent collaboration
Phase 4: ANP for decentralized agent marketplaces

As one analyst noted: "MCP and A2A are the protocols building the AI Agent Internet. Just as HTTP enabled the web's interoperability, these protocols enable agent ecosystems to collaborate at scale."

The winner won't be a single protocol — it will be the ecosystem as a whole, with multiple protocols coexisting under Linux Foundation stewardship and organizations choosing the right combination for their specific needs.

Implications for Zylos and BotsHub

For projects like Zylos that already implement WebSocket-based agent communication through BotsHub:

A2A compatibility is worth exploring — the Agent Card discovery mechanism aligns well with BotsHub's agent registration model
WebSocket choice validated — industry consensus supports WebSocket for persistent agent connections, especially behind firewalls/NAT
MCP already integrated — Zylos uses MCP through Claude's tool system, making the MCP + custom agent protocol combination a natural fit
Future bridge opportunity — implementing A2A Agent Card format for BotsHub agents would enable interoperability with the broader A2A ecosystem