Every few weeks someone publishes a comparison of MCP, A2A, and Pilot Protocol as if you have to pick one. I have seen the charts. One column per protocol, rows for features, checkmarks and crosses. They are almost always wrong, not because the facts are wrong but because the framing is wrong.

These three protocols do not compete with each other. They sit at different layers of the same stack. Choosing between them is like choosing between TCP and HTTP. The question does not make sense because one is a transport and one is an application protocol and you need both.

Here is where each one actually lives, and why a real multi-agent system will likely end up using all three.

MCP: your agent talks to tools

Model Context Protocol is Anthropic's specification for how an agent connects to external tools and data sources. An agent holds an MCP client. MCP servers expose tools through a standardized JSON-RPC interface. The agent calls the tool, gets a result, and continues.

The mental model is a plugin system. Your agent does not need to know how to read a database, call a search API, or parse a PDF. It connects to MCP servers that know how to do those things and calls them through a common interface.

MCP is vertical. It describes the relationship between an agent and the tools it uses. It has nothing to say about how agents talk to each other.

A2A: your agent delegates to another agent

Agent-to-Agent protocol is Google's specification for how agents coordinate work with each other. It defines how an agent advertises its capabilities, how another agent submits a task to it, and how status and results flow back. It was donated to the Linux Foundation in June 2025 and now has over 150 supporting organizations.

The mental model is a work contract. Agent A knows it needs to do something it is not specialized for. It finds agent B, which is. A2A defines the structured conversation between them: here is the task, here is the format, here is how you tell me when you are done.

A2A is horizontal at the application layer. It describes the protocol between agents for delegating and tracking work. It assumes the two agents can already reach each other. It does not specify how they find each other or how they establish a connection across a network.

Pilot Protocol: your agents find each other and connect

Pilot Protocol is the network layer that sits underneath agent-to-agent communication. Each agent runs a local daemon. The daemon assigns the agent a virtual address derived from its Ed25519 keypair, handles NAT traversal so agents behind different firewalls can reach each other directly, and encrypts all traffic with X25519 and AES-256-GCM.

The mental model is an overlay network. Where the public internet routes packets by IP address, Pilot routes by virtual address. Your agent's virtual address is stable across restarts and cloud migrations because it comes from the key, not the host. When agent A wants to talk to agent B, it uses B's virtual address. The daemon figures out the path.

Pilot Protocol is horizontal at the network layer. It has nothing to say about message format or task delegation. It just makes sure the message gets there.

What a real stack looks like

Here is a concrete example. Suppose you are building a research pipeline with three agents: a coordinator, a web researcher, and a document analyst.

The coordinator uses MCP to connect to a search tool and a file system tool. When it needs to do a deep read on a document it finds, it delegates that task to the document analyst using A2A: here is the document, extract the key claims, return them structured. The document analyst accepts the task and returns a result in the A2A format the coordinator expects.

Both agents discovered each other through the Pilot network. When the coordinator sends the A2A task payload to the document analyst, that message travels over an encrypted Pilot tunnel. The analyst may be running on a different cloud provider behind a NAT that would normally block direct connections. The Pilot daemon handles that transparently.

MCP is handling the coordinator's tool calls. A2A is handling the delegation between agents. Pilot is handling the transport between agents. None of them are doing the same job.

Where people get confused

The confusion usually starts with the fact that all three protocols involve messages between a process and something external. MCP has request-response. A2A has request-response. Pilot has send-message. If you only look at the surface, they look similar.

The difference is what is on each end and what the message means.

MCP connects an agent to a tool. The agent is the client and the tool is a specialized server. The relationship is asymmetric. The tool does not initiate tasks back to the agent.

A2A connects an agent to an agent for the purpose of delegating work. Both sides are peers, but the protocol is specifically about task assignment and status tracking. It does not care how the underlying bytes get from one process to the other.

Pilot connects an agent to the network. It is not about what the message means. It is about whether the message arrives at all, whether it is encrypted, and whether the sender can verify who they are talking to.

What each one leaves out

MCP does not define how agents coordinate with each other. It defines how an agent uses a tool.

A2A does not define how agents reach each other across real network conditions. The arXiv survey on agent protocols covering MCP, A2A, ACP, and ANP is useful here: every one of these protocols assumes connectivity already exists.

Pilot does not define what agents say to each other. It does not know or care whether you are using A2A task format, a custom JSON schema, or plain text. It sends bytes from one virtual address to another.

These are not weaknesses. They are boundaries. A protocol that tries to be all three of these things at once would be much harder to implement, much harder to reason about, and much harder to extend.

The short version

Use MCP when your agent needs to call a tool or read external data.

Use A2A when one agent needs to delegate structured work to another agent and track the result.

Use Pilot Protocol when your agents need to find each other, connect across different networks and cloud providers, and communicate over an encrypted peer-to-peer channel.

In a production multi-agent system you will probably end up reaching for all three.

• MCP spec: modelcontextprotocol.io
• A2A spec: google.github.io/A2A
• Pilot Protocol: pilotprotocol.network
• Agent protocol survey (MCP, A2A, ACP, ANP): arxiv.org/html/2505.02279v1
• Install Pilot: curl -fsSL https://pilotprotocol.network/install.sh | sh