“Language is the medium of intelligence—when agents speak, coordination becomes cognition.” — Inspired by Marvin Minsky
When Agents Talk: The Rise of Agent2Agent (A2A) Protocol in a Post-MCP World
Introduction
In the rapidly evolving landscape of autonomous agents, interoperability is no longer a luxury—it’s a necessity. As AI systems become increasingly modular, decentralized, and multi-agent in nature, protocols for communication and coordination between agents have surged in importance. One of the most promising innovations in this domain is the Agent2Agent (A2A) protocol, a communication standard designed to enable seamless, secure, and semantically rich interactions between AI agents.
But A2A doesn’t operate in a vacuum. It’s rising as a challenger—and in some cases, a complement—to the Model Communication Protocol (MCP) that has dominated the early wave of AI orchestration. This post traces A2A’s origin, compares it with MCP, explores where it shines, and dives into technical patterns and code examples shaping its adoption.
Historical Context: From Monoliths to Modular Agents
The early wave of AI development followed a centralized paradigm. Think monolithic models behind APIs—OpenAI’s GPTs, Google’s PaLM, Anthropic’s Claude. But as developers sought more customizable, composable systems—especially in enterprise and open-source ecosystems—multi-agent architectures began to surface.
That’s where Model Communication Protocol (MCP) came in, popularized by projects like LangChain and AutoGPT. MCP provided a rudimentary but serviceable way for AI agents to coordinate by passing structured prompts and responses. It leaned heavily on predefined schemas and centralized routing logic.
But as use cases grew—especially for agent autonomy, negotiation, delegation, and decentralized planning—the need for a more extensible, semantically aware, peer-to-peer protocol became clear. That’s where Agent2Agent (A2A) emerged.
What is A2A?
Agent2Agent (A2A) is a decentralized communication protocol designed for autonomous agents to exchange messages, delegate tasks, and share context in a standardized, secure, and extensible format. It’s inspired by and builds on lessons from:
- FIPA ACL (Foundation for Intelligent Physical Agents Agent Communication Language)
- Verifiable credentials and decentralized identity (DIDComm)
- Modern event-driven microservice patterns
A2A is not just about syntax; it’s about semantics. The protocol includes intent-based communication primitives such as:
- REQUEST
- INFORM
- OFFER
- NEGOTIATE
- ACCEPT/DECLINE
- FORWARD
- ACK
These are not simple API calls—they are performative speech acts that carry meaning and context, allowing agents to reason about responses, retry logic, delegation, and trustworthiness.
Who Created A2A?
The protocol’s development has been driven by a coalition of open-source developers, decentralized identity (DID) advocates, and contributors from the Indy, Hyperledger Aries, and AgentOS ecosystems. A2A is particularly influenced by work from:
- Daniel Hardman – Former Sovrin Foundation CTO and contributor to Hyperledger Aries’ secure messaging protocols.
- Sam Curren – Creator of the Aries Interop Profile, which evolved into a secure agent messaging layer and later influenced A2A semantics.
- The DIF (Decentralized Identity Foundation) – Which helped formalize schemas and communication envelopes used in A2A.
A2A vs MCP
| Feature | A2A | MCP |
| Philosophy | Decentralized, peer-to-peer | Centralized orchestration or controller-agent |
| Message Semantics | Rich with performative intent | Mostly task/prompt-based JSON or YAML |
| Security | Built-in encryption, signatures, DID support | Ad-hoc or depends on infrastructure |
| Extensibility | Schema-agnostic with defined speech acts | Task-defined schemas with limited negotiation |
| Trust Model | Verifiable identities and credentials | Often implicit or trusted runtime environment |
| State Management | Supports dialogue state and protocol threading | Stateless interactions unless manually handled |
In short, MCP is sufficient for linear pipelines, but A2A excels in autonomy, delegation, and long-running dialogues between agents.
Real-World Applications and Patterns
- Multi-agent Planning & Delegation
- Agents can delegate tasks to others with specific REQUEST and OFFER patterns.
- Use case: One agent responsible for data extraction delegates visualization to another, who in turn delegates distribution to a notification agent.
- Supply Chain and Procurement
- Agents representing vendors and buyers negotiate via NEGOTIATE, OFFER, COUNTER, and ACCEPT messages.
- Verifiable credentials are used to prove certification, compliance, or payment readiness.
- Decentralized Autonomous Organizations (DAOs)
- Proposals are modeled as INFORM or OFFER, and votes/endorsements as ACCEPT/DECLINE.
- Smart contracts can trigger based on A2A message receipts.
- Federated AI Systems
- Agents at the edge communicate updates or model changes using INFORM and FORWARD, all signed and auditable via A2A envelopes.
Technical Deep Dive & Code Example
A basic A2A message looks like this (JSON-LD or JWM – JSON Web Message):
{
"@type": "https://didcomm.org/basicmessage/1.0/message",
"@id": "1234567890",
"from": "did:example:agent1",
"to": ["did:example:agent2"],
"body": {
"content": "Requesting price quote for item SKU-9217"
},
"created_time": 1715347200,
"expires_time": 1715348200,
"attachments": []
}Wrapped in a JWM envelope, this message is encrypted with agent2’s public key and signed by agent1. The @type defines the protocol handler.
Libraries and Frameworks Supporting A2A:
- Hyperledger Aries Framework Python/Go/JavaScript: Implements A2A message threading, DIDComm routing, and connectionless interactions.
- Indy-SDK: Used for credential issuance and identity verification, often integrated with A2A protocols.
- AgentOS: An emerging platform for running composable agents that leverage A2A to coordinate workloads and negotiate tasks.
Example Pattern: Protocol Threading
Each A2A interaction maintains a ~thread:
"~thread": {
"thid": "1234567890", // thread ID
"pthid": "0987654321" // parent thread
}This allows long-running workflows, message retries, and dialog chains to be logically connected—even across offline states.
What Good Looks Like
- IDUnion: A cross-border identity network in Europe leveraging A2A over DIDComm for verifiable interactions between autonomous identity agents.
- Digital Bazaar’s Veres One: Implements credential exchange and task negotiation via A2A within a self-sovereign web ecosystem.
- AgentOS Use Case Demo: A “helpdesk” scenario where a customer service agent coordinates with a billing agent and scheduling agent through intent-driven messages.
What Can Go Wrong
- Inconsistent Message Handling: Without a shared understanding of @type semantics, agents can misinterpret intents. Versioning and schema registration are vital.
- Identity Spoofing: If DID resolution or signature validation isn’t rigorously enforced, agents can be impersonated—especially dangerous in financial or DAO contexts.
- Too Much Autonomy, Too Soon: Poorly governed delegation (e.g., an agent that keeps reassigning work recursively) can create infinite loops or denial-of-service conditions.
Emerging Trends
- LLMs wrapped in agents using A2A for self-delegation, memory sharing, or negotiating over tool access.
- Multi-modal A2A: Extending the protocol to handle not just text but visual, auditory, and binary instructions between agents.
- Trust Scores: Reputation-based filtering and trust frameworks (inspired by PageRank or web-of-trust) to determine which agents to trust and delegate to.
Wrapping up…
Agent2Agent (A2A) is more than just a message format—it’s a step toward true inter-agent cognition. As systems shift from toolchains to ecosystems, from functions to behaviors, A2A offers a path to orchestrate autonomy at scale.
It may not replace MCP in every scenario, but in environments demanding peer-to-peer communication, context maintenance, or rich semantic exchange, A2A is the future of how agents talk.
