Agent Interoperability Protocols: MCP vs A2A vs ACP vs ANP Diagrams (2026)

How to diagram agent interoperability architectures in 2026. Covers MCP, A2A, ACP, and ANP — with architecture patterns, comparison tables, and prompt templates for each protocol.

Ryan·Senior AI Engineer

·Last updated June 8, 2026

Four major protocols are competing to become the connective tissue of the agentic web. Each answers a different question about how AI agents should communicate: how they access tools and data, how they delegate tasks to each other, how they exchange messages across systems, and how they discover each other across the open internet. Understanding the architectural boundaries of each — and diagramming which protocols belong at which layer of your system — is one of the most important design decisions for teams building production multi-agent applications in 2026.

This guide covers the four protocols — MCP, A2A, ACP, and ANP — explains what architectural problem each solves, shows how they can coexist in a single system, and provides prompt templates for generating accurate protocol diagrams in ArchitectureDiagram.ai.

The four-protocol landscape at a glance

These protocols operate at different layers of the agent interaction stack, which is why they can coexist rather than compete:

MCP (Model Context Protocol, Anthropic / Linux Foundation) — connects agents to tools and data sources. Vertical: agent ↔ capability.
A2A (Agent2Agent, Google) — enables task delegation between agents in enterprise systems. Horizontal: agent ↔ agent (same org).
ACP (Agent Communication Protocol, IBM / BeeAI) — provides RESTful message exchange between agents with multi-modal message envelopes. Horizontal: agent ↔ agent (cross-framework).
ANP (Agent Network Protocol) — enables open discovery and communication across organizational boundaries using W3C DIDs. The "HTTP of the agentic web."

MCP: connecting agents to capabilities

Model Context Protocol was introduced by Anthropic in late 2024 and donated to the Linux Foundation in December 2025, making it a vendor-neutral open standard. MCP solves the tool integration problem: rather than every agent framework defining its own way to connect to a database, file system, or API, MCP provides a standard client/server protocol that any agent can use to discover and call capabilities exposed by any MCP server.

MCP architecture diagram elements: MCP Host (the AI application), MCP Client (protocol adapter inside the host), MCP Servers (capability providers), Transport layer (stdio for local servers, HTTP+SSE for remote). See the full MCP architecture guide for detailed patterns.

When to use MCP: Whenever an agent needs to call external tools — reading files, querying databases, calling APIs, executing code. MCP is the correct layer for agent-to-tool communication in virtually every modern AI application.

A2A: task delegation between enterprise agents

Agent2Agent is Google's open protocol for delegating tasks between AI agents within enterprise environments. Where MCP connects agents to static capabilities (tools), A2A connects agents to other agents that can dynamically fulfill tasks. By June 2026, A2A had over 150 supporting organizations including Salesforce, SAP, ServiceNow, and the major cloud providers.

The core A2A architecture has three roles:

Client Agent: The agent that wants to delegate a task. It discovers remote agents via their Agent Card — a JSON document at a well-known URL that describes the agent's capabilities, supported input/output formats, and authentication requirements.
Remote Agent: The agent that receives and executes the delegated task. It exposes an HTTP endpoint that accepts A2A task requests.
Task: The unit of work. A task has a lifecycle (submitted → in_progress → completed/failed) and can include multi-modal artifacts (text, files, structured data) in both the request and response.

A2A architecture diagram elements: Client Agent, Agent Card registry (or well-known URL), Remote Agent, Task object with lifecycle states, streaming response channel (SSE for long-running tasks), authentication layer (OAuth 2.0 / API key).

When to use A2A: When you need one AI agent to delegate a complete subtask to another agent that lives in a different service, team, or vendor's system. A2A is well-suited for enterprise orchestration patterns: an orchestrator agent delegating data analysis to a Salesforce agent, or a support agent escalating to a specialist compliance agent.

ACP: cross-framework agent messaging

Agent Communication Protocol was introduced by IBM as part of the BeeAI project and is designed to be the minimal, RESTful messaging protocol for direct agent-to-agent communication — regardless of which AI framework each agent was built with. While A2A is optimized for enterprise task delegation with rich lifecycle management, ACP is lower-level: a simple HTTP request/response with multi-modal message envelopes (text, images, files, structured data).

ACP architecture diagram elements: ACP Client (sending agent), ACP Server (receiving agent), Message envelope (multi-modal parts), Synchronous run endpoint, Asynchronous run-async + stream endpoints, ACP Agent Registry for discovery.

When to use ACP: When you need lightweight cross-framework agent communication without the full A2A task lifecycle. ACP is well-suited for pipeline architectures where agents in different frameworks (LangChain, CrewAI, a custom Claude agent) need to pass data and partial results to each other without a shared state model.

ANP: open discovery across organizational boundaries

Agent Network Protocol is the most ambitious of the four protocols — it aims to be the "HTTP of the agentic web." ANP uses W3C Decentralized Identifiers (DIDs) for agent identity and discovery, allowing agents from completely different organizations to find and communicate with each other without a central registry. An agent publishes its capabilities in an Agent Description Document (analogous to an OpenAPI spec) hosted at its DID URL. Any other agent can resolve that DID, discover the capabilities, and initiate communication using the ANP meta-protocol.

ANP architecture diagram elements: Agent DID document, DID resolver, Agent Description Document (capabilities + auth requirements), ANP handshake protocol, Message exchange layer, Trust framework (DID authentication).

When to use ANP: When agents from different organizations need to discover and interact with each other without pre-arranged integrations. ANP is the right choice for open agentic marketplaces, cross-company AI workflows, and scenarios where you want your agent to be discoverable by any other ANP-compatible agent on the internet.

Protocol comparison and decision matrix

Dimension	MCP	A2A	ACP	ANP
What it connects	Agent ↔ Tool/data	Agent ↔ Agent (task)	Agent ↔ Agent (message)	Agent ↔ Internet
Discovery	Config / registry	Agent Card URL	ACP Registry	W3C DID resolver
Transport	stdio, HTTP+SSE	HTTP + SSE (async)	HTTP REST	HTTP + meta-protocol
Auth	Per-server (API key, OAuth)	OAuth 2.0 / API key	Pluggable	DID-based cryptographic
Task lifecycle	Tool call / result	Full (submitted → done)	Run / run-async / stream	Protocol-negotiated
Governance	Linux Foundation	Google (open spec)	IBM / BeeAI (open)	Community / W3C alignment
Maturity (2026)	Production-ready	Production-ready	Early production	Emerging / experimental

Prompt templates for multi-protocol architecture diagrams

Enterprise AI platform with MCP + A2A

"An enterprise AI platform that combines MCP and A2A. An orchestrator agent (Claude claude-opus-4-8) uses MCP to connect to internal data sources: a Postgres MCP server (customer data), a Confluence MCP server (documentation), and a code execution MCP server (Python sandbox). For tasks requiring specialized expertise, the orchestrator delegates via A2A: it reads the Agent Card of a Salesforce agent at https://agents.internal/salesforce/.well-known/agent.json to discover its capabilities, then creates an A2A task for CRM operations. It also delegates to a Compliance agent (via A2A) for regulatory review tasks. The Salesforce and Compliance agents each have their own MCP server connections to their respective systems. Show the two-layer architecture: MCP as the vertical tool-access layer (each agent to its own tools) and A2A as the horizontal task-delegation layer (between agents)."

Cross-framework agent pipeline with ACP

"A data processing pipeline where three agents built on different frameworks communicate via ACP. Agent 1 (a LangChain agent) receives raw documents and performs extraction, sending structured JSON to Agent 2 via an ACP run-async call. Agent 2 (a CrewAI crew) performs multi-step analysis and streams partial results back via ACP streaming. Agent 3 (a custom Claude agent) receives the analysis and generates a final report, returning it via a synchronous ACP run call. All three agents are registered in a shared ACP Agent Registry. Show the ACP message envelope at each step, highlighting the multi-modal parts (input: text document, output: structured JSON + text). Use a pipeline swimlane layout with ACP as the protocol connector between frameworks."

Open agentic marketplace with ANP discovery

"An open agent marketplace where service-provider agents are discoverable via ANP. Three provider agents each publish a DID document and Agent Description Document: a legal review agent (lawfirm.com), a translation agent (lingua.ai), and a compliance check agent (compli.io). A client orchestrator agent discovers these agents by resolving their DIDs via a W3C DID resolver. After discovery, the orchestrator uses the ANP meta-protocol to negotiate communication parameters and then delegates subtasks to each provider. Show the DID resolution flow as a separate discovery phase before the task execution phase. Highlight the organizational boundary separating the client and provider agents — ANP spans this boundary without pre-arranged integration agreements."

Frequently asked questions

Do I need all four protocols in my system?

Almost certainly not. Most production systems in 2026 use MCP for tool access and either A2A or ACP for agent-to-agent delegation — and often just one of those. ANP is relevant only if you need agents to discover and interact with external agents across organizational boundaries without pre-arranged integrations. Start with MCP (it's foundational for any agent with external tool access), add A2A if you need enterprise task delegation across agent boundaries, and consider ACP if you're building a cross-framework pipeline. ANP is worth monitoring but is experimental for most teams in 2026.

What is the difference between MCP and A2A?

MCP connects an agent to tools and data sources — it is a vertical protocol for capability access. A2A connects one agent to another agent for task delegation — it is a horizontal protocol for agent collaboration. An agent might use both simultaneously: MCP to access its own tools (database, file system, code executor) and A2A to delegate a specialized subtask to a different agent that has its own tools. They operate at different layers and are complementary, not competitive.

What is an Agent Card in A2A?

An Agent Card is a JSON document published by an A2A-compatible agent at a well-known URL (typically /.well-known/agent.json). It describes the agent's capabilities (which tasks it can handle, what input formats it accepts, what outputs it produces), supported authentication mechanisms, endpoint URL, and streaming support. A client agent fetches the Agent Card to discover a remote agent's capabilities before delegating a task — similar to how an OpenAPI spec describes a REST API's capabilities before a client calls it. In your architecture diagram, show Agent Cards as the discovery mechanism that connects client agents to remote agents.

Ready to try it yourself?

Start Creating - Free