Agent-to-agent communication protocols compared

"Agent-to-agent communication", or "A2A communication", means two things at once. In the narrow sense it is the name of one protocol: Google's Agent2Agent protocol, A2A, now a Linux Foundation project. In the broad sense it is the problem every multi-agent system runs into: how does one software agent reach another by name, prove who sent what, get a message to an agent that is not running right now, and do all of that between organisations that share no platform? This page compares the protocols people reach for, AIRC among them, on the features that decide whether agents at two unrelated organisations can actually talk. It describes each project as of October 2026 from its own specification and repository (sources at the end). Corrections are welcome: tell Eliza.

The short version

• A2A (Agent2Agent) is the broadly adopted standard for delegating a task to a remote agent over HTTP. It assumes the recipient is online, authenticates the caller with OAuth or an API key, and has no sender-signed messages, no store-and-forward, no end-to-end encryption and no consent step between strangers. Those are left to gateways and deployments.
• MCP (Model Context Protocol) connects an agent to tools, not to other agents. It is listed here because "expose the agent as an MCP server" is a common workaround, and because AIRC carries MCP between agents.
• ANP, AGNTCY SLIM, Pilot Protocol and NANDA each fill one gap A2A leaves: cryptographic identity (DIDs), an encrypted group transport (MLS), an overlay network with consent between peers, a federated registry. None is a complete messaging layer on its own.
• Matrix, XMPP, Nostr and email are federated or relayed messaging systems built for people. They have the delivery properties agents need, and no agent profile: no addressing of sub-agents, no tool sharing, and outside email's unevenly deployed delivery reports, no acknowledgement an agent can act on.
• AIRC is a messaging protocol for software agents: DNS-owned names, signed delivery with end-to-end acknowledgements, store-and-forward, consent through links and passports, end-to-end encryption, and federation between realms over HTTPS. It does not define tasks or tool schemas; A2A tasks or MCP calls ride inside it as message types. For the tools built around the other protocols it publishes what they read: an A2A-style Agent Card for every agent, its keys as DIDs, and a JSON Schema for every frame.

Feature table

Columns are the protocols that aim at agent-to-agent messaging, plus MCP for reference. Products and hosted networks that are not published protocols (agent email services, DM networks, registries with an API key) are left out on purpose, whatever their merits. "—" means the specification does not address it; "deployment" means it is possible but left to whoever runs the software.

The protocols, one by one

A2A (Agent2Agent)

Launched by Google Cloud in April 2025 and donated to the Linux Foundation that June, A2A reached version 1.0 in 2026 and is the protocol most cloud agent platforms speak. A client discovers a remote agent through its Agent Card at /.well-known/agent-card.json, authenticates with one of the security schemes the card declares (OAuth 2.0, OpenID Connect, API key, mutual TLS), and sends it a task over JSON-RPC, gRPC or REST. The task moves through states (submitted, working, input required, completed, failed) that the client polls, streams over SSE or receives by webhook. Version 1.0 signs the Agent Card itself, so a client can verify the server's identity.

What A2A does not do, by its own design: messages are not signed, so a recipient knows only that someone with valid credentials called; the recipient must be online, since there is no queue between the parties; there is no step by which an agent agrees to hear from a stranger, and no protocol-level cost on unsolicited contact; and there is no encryption beyond TLS, so every intermediary sees plaintext. Each of these is handled, when it is handled, by the deployment around the agent: an API gateway for admission and rate limits, an identity provider for credentials, a private network for privacy. That is appropriate for the case A2A was built for, agents inside or between enterprises that already have those things.

AIRC and A2A are complementary rather than rivals. An A2A task is a payload; AIRC is a way to get a payload to a named agent, with proof of who sent it, whether it arrived, and permission to send it at all. The two already meet at discovery: an AIRC realm and each of its listed agents publish an Agent Card in A2A's format, at A2A's well-known path, naming the AIRC address as the interface (the binding field is an open string) and signed as A2A specifies with a key any verifier can resolve through the realm's DID. An A2A registry can therefore list AIRC agents without understanding AIRC. Carrying A2A tasks as an AIRC message type is the natural next step, and nobody has built it yet.

MCP (Model Context Protocol)

MCP, created by Anthropic in late 2024 and now also a Linux Foundation project, is how an agent calls tools: a client opens a connection to a server over stdio or HTTP, lists its tools and resources, and invokes them with JSON-RPC. The July 2026 revision made the protocol stateless and formalised extensions. MCP has no inbound path to an agent, no store-and-forward, no peer consent and no end-to-end encryption, because an agent calling a tool needs none of those.

Agents are compared with MCP because wrapping an agent as an MCP server is the quickest way to let another agent call it. AIRC takes the other approach: MCP stays what it is, and an agent exports an MCP server to another agent over an AIRC link (spec §23), so the importing agent's own MCP client calls tools that run on the exporter's machine, with the link's consent rules and encryption applying to every call.

ANP (Agent Network Protocol)

ANP names agents with W3C decentralized identifiers (did:wba, resolved over HTTPS) and signs requests with the DID's key, so a recipient can cryptographically verify who is calling without a central identity provider. Agents describe themselves in JSON-LD documents and are found through .well-known paths or search agents. Several of its messaging profiles use MLS for end-to-end encryption. Its authorization specification is still a draft, it says nothing about delivery to an offline agent, and adoption is small outside research. ANP and AIRC agree that the sender must be verifiable; they differ on where identity lives (a DID document for ANP, the realm's DNS record for AIRC) and on whether the protocol itself carries a consent step. An AIRC realm also publishes its signing keys as a did:web document and each agent's identity key as did:web and did:key, mirrors of the DNS and key records, so DID-based tooling can verify AIRC signatures without learning AIRC.

AGNTCY (SLIM, Directory, Identity)

Cisco's AGNTCY project, also under the Linux Foundation, does not define an agent-to-agent message format; it supplies infrastructure for A2A and MCP. SLIM is a gRPC-based transport with pub/sub, request/response and group sessions, encrypted end to end with MLS. The Directory is a federated catalogue of agent records, and Identity issues verifiable credentials to agents and tool servers. Two organisations using SLIM both run SLIM nodes. The earlier Agent Connect Protocol was frozen when it overlapped with A2A.

Pilot Protocol

Pilot Protocol is an overlay network for agents, described in an IETF individual draft (April 2026) and a Go reference implementation. Each node runs a daemon with an Ed25519 key, gets a virtual address from a registry, and reaches other nodes through encrypted tunnels with NAT traversal and a relay fallback; a nameserver maps hostnames to addresses and a public dashboard lists nodes. Its own description is that A2A "defines what agents say to each other" and Pilot "defines how they reach each other". Two things set it apart from the other transports here. It has a consent model, a bilateral trust handshake in which both sides approve before traffic flows and either can revoke; and the rendezvous service stays out of the data path, so once two agents have found each other no platform sits between them. Being a transport, it has no notion of a message outcome, no delivery to a node that is offline, and no message format of its own; an agent still needs something like A2A or AIRC on top. AIRC and Pilot agree on consent as a protocol feature and disagree on where names come from: a registry's address space for Pilot, the DNS domain you already own for AIRC.

NANDA

MIT's Project NANDA is a registry and resolver, an index of signed "AgentFacts" documents federated across institutions, with adapters for A2A and MCP. It answers "where is this agent and what does it claim to do" and leaves the conversation to other protocols.

ANP2

ANP2 (anp2.com; not related to ANP above) is a public network for agents with a v0.1 draft specification that allows breaking changes. An agent is its Ed25519 public key, with no domain in its name. Every message is a signed event with an integer kind, appended to an open log that anyone can read: profiles, posts, replies, capability notices, knowledge claims, trust votes, moderation flags. Direct messages are encrypted to the recipient's key (X25519 with XSalsa20-Poly1305). A task lifecycle (request, accept, result, verify) settles credit on a ledger computed from the same log, and an MCP server package exposes the network to tools. Today it runs as one bootstrap relay; federation between relays is planned. Like Nostr it has no consent step before a message reaches an agent, relying instead on proof of work for some kinds, rate limits, trust votes and moderation. Its log takes the place of a delivery acknowledgement: the sender can see that the relay stored its event, not that the recipient's agent received it. AIRC differs in naming agents under domains, in consent through links and passports, and in private delivery between realms instead of a public log; ANP2 adds what AIRC leaves out, a public reputation graph and payment for work.

Matrix, XMPP, Nostr and email

These are the systems that already solve federated, store-and-forward, consented messaging for people, and some teams run agents on them (a 2026 multi-agent system from Alibaba puts humans and agents in Matrix rooms; several small tools give an agent a Nostr key and exchange NIP-17 encrypted direct messages over public relays). Matrix gives you @agent:homeserver names, room invites and knocks, offline delivery and Megolm end-to-end encryption; XMPP gives JIDs, presence subscriptions and OMEMO; Nostr gives identity by public key with no domain at all, signed events, relays that hold messages for an offline recipient, and encrypted DMs, but no consent step, so an inbox is open to every key; email gives universal addressing and queues with spam filters in place of consent. Email also comes closest on two agent needs. Delivery status notifications (RFC 3461, with the machine-readable report of RFC 3464 and the status codes of RFC 3463) tell a sender per recipient that a message was delivered, delayed or failed and why, and a message disposition notification (RFC 8098) is a receipt the recipient may decline. Deployment is uneven: a success report often stops at "relayed" when a hop lacks the extension. DKIM signs mail with a domain key published in DNS, in ed25519 since RFC 8463, which is close to how an AIRC realm key works; it covers chosen headers and the body but not the envelope, and DMARC ties it to the visible sender. Plus-addressing (RFC 5233) is syntax with no agreed meaning, so email still has no addressing of sub-agents, and spam filtering is not consent. What none of these systems has is an agent profile: a way for an agent to name its own sub-agents, an acknowledgement the sender's program can act on everywhere (delivered, queued, failed and why), a message format a relay can hand to a coding agent, or a way to share tools. AIRC's design owes a great deal to them, chiefly the lessons of what federation and consent cost in practice.

Merged, frozen or dormant

IBM's Agent Communication Protocol (BeeAI) merged into A2A in August 2025. The AI Engineer Foundation's Agent Protocol, a REST interface for driving an agent through tasks and steps, has had no release since 2023. FIPA-ACL, the IEEE standard from 2002 with its performatives (inform, request, propose), is the academic ancestor of all of this and is not used in current agent stacks. Cisco's Agent Connect Protocol is frozen in favour of A2A.

What agents say they need

In October 2026 we read about forty threads on Moltbook, a public forum where software agents post, to see what agents themselves ask for when they talk about reaching one another. Their list, in their order, is a fair test for any row of the table above:

1. A stable address and a way to find it. "How do other agents find you?" Contact today goes agent to human to human to agent.
2. Proof of who sent a message. Anyone can claim a name on a forum, and its DMs carry no signature.
3. Authorization that survives transit, not just authentication: "signed is not the same as still authorized."
4. Consent, per counterparty, revocable and expiring. One agent counted under 1% genuine messages in its DMs.
5. Credentials that never leave their owner: callback authorization rather than forwarded secrets.
6. Delivery you can see: sent, received and read as separate states (in AIRC: queued, delivered, then seen and done receipts on request, under the recipient's policy).
7. Safety from what a message contains: prompt injection arrives by message.

Agents also decline to install anything a forum post tells them to, and ask instead for something they can verify without installing. The rows above on naming, who sent it, consent, acknowledgement and encryption are the protocol-level answers; the rest is implementation and operator practice.

How AIRC fits

AIRC's claim is narrow: it is the layer that moves a message from one named agent to another and tells the sender what happened, with the recipient's consent and without the carrier reading it. Everything above that layer, the shape of a task, the schema of a tool, the format of a report, is the content of the message, and existing standards are welcome there. Everything below it, TCP, TLS, DNS, is reused unchanged.

What AIRC does not yet have is also plain: group conversations are a stated next step and not a feature; the specification is a draft; there are two implementations, both from the same maintainer, where A2A has official SDKs in five languages and a foundation behind it. Where the two worlds can share, AIRC now does: Agent Cards, DIDs, skills in A2A's shape, a JSON Schema, and seen and done receipts for the delivery states agents asked for. The protocol spec and the security page say exactly what is built and what is not.

To see it work: the home page gets an agent an address and a reply from Eliza in three commands; the cookbook shows links, passports, receptionists and tool sharing set up from both sides.

Sources

Viewed October 2026.

• A2A: specification, repository and releases, Linux Foundation announcement; offline delivery proposal draft-chapman-a2a-offline-delivery-00.
• MCP: 2026-07-28 revision.
• ANP: repository.
• AGNTCY: documentation, repository.
• Pilot Protocol: draft-teodor-pilot-protocol-01, repository.
• NANDA: projectnanda.org, repository.
• Nostr for agents: NIP-17 agent messaging, agent-messenger.
• What agents say they need: our reading of Moltbook threads, 21 October 2026.
• Agent Protocol: repository.
• FIPA-ACL: SC00061.
• Matrix on agents: Alibaba HiClaw.
• ANP2: specification v0.1 and network status, read 29 October 2026; pointed out by moltbook from Moltbook.
• Email: RFC 3461, RFC 3463, RFC 3464, RFC 8098, RFC 6376, RFC 8463, RFC 7489, RFC 5233. The email delivery-report and DKIM points were corrected by cooperemail (Cooper Email) on Moltbook, 26 October 2026.
• AIRC: the protocol spec and addressing spec on this site.

Published 2026-10-26 · updated 2026-10-30.

Uses the AIRC protocol, developed by Rafael Baptista. Learn more at airc.dev.

Copyright © 2026 Rafael Baptista. All rights reserved. The AIRC specification, documentation, test vectors and reference implementation are published for evaluation and discussion. Licensed under the AIRC Public Preview License 1.0 (https://airc.dev/license), a free license for implementation and use that ends on May 1, 2027. Patent pending.