Google's open protocol for agent-to-agent communication, donated to the Linux Foundation — the complement to MCP. Where MCP standardizes agent-to-tool, A2A standardizes agent-to-agent, so agents built on different frameworks or by different vendors can discover and collaborate with each other.
Core concepts
- Agent Cards: A discoverable manifest describing what an agent can do, so another agent (or orchestrator) knows how to delegate a task to it.
- Task-based communication: A2A models interaction as long-running tasks with state, not just single request/response calls — suited to agents that take time to complete work.
- Framework-agnostic by design: An A2A-compliant agent built in LangGraph can hand work to one built in CrewAI or a custom stack — this is the interoperability layer MCP doesn't cover.
- MCP vs A2A in one sentence: MCP connects an agent to tools and data; A2A connects agents to each other — most production systems eventually need both patterns.
- Google ADK & A2A: Google's Agent Development Kit (ADK) ships with first-class A2A support for building agents that advertise capabilities via Agent Cards and accept delegated tasks from orchestrators.
What Is It?
A2A standardizes agent-to-agent tasks and capability advertisement.
Donated to the Linux Foundation for neutral governance.
Framework-agnostic — agents written in different stacks can interoperate.
Why Should I Care?
Enterprise workflows split work across specialized agents (billing, support, research).
Interoperability beats monolithic mega-agents.
Real World Analogy
A2A is LinkedIn for agents — Agent Cards are profiles saying what each agent can do and how to message them for tasks.
Visual Mental Model
Agent A --task--> Agent B
Agent Cards for discoveryBeginner Explanation
Google's A2A lets agents discover peers via Agent Cards and exchange task-based messages — complementary to MCP's tool focus.
Smallest Possible Example
# Agent Card describes skills + endpoint
AGENT_CARD = {"name": "billing", "skills": ["refund"]}Common Mistakes
❌ Using A2A without clear task boundaries.
Vague tasks ping-pong forever; define inputs/outputs.
❌ Skipping authentication between agents.
Agent endpoints are APIs — protect them.
❌ Confusing A2A with MCP.
MCP connects tools/data; A2A connects agents as peers.
Real Project Example
Google Cloud AI agents roadmap references A2A for partner integrations.
Multi-vendor agent marketplaces experiment with Agent Cards.
Build This Mini Project
Draft an Agent Card JSON for a fake 'refund agent' with skills, input schema, and endpoint URL fields.
Interview Question
MCP vs A2A?
MCP standardizes how one agent connects to tools and data sources; A2A standardizes how agents delegate tasks to other agents — complementary layers.
Key Takeaways
- Agent Cards advertise capabilities.
- Task-based messaging between agents.
- Secure agent endpoints.
- Complements MCP, not replaces it.
Resources
YouTube learning
Core concepts from video walkthroughs:
The 60-second story
MCP gave the employee a calculator. A2A is how two employees from different companies hand each other a job without sharing a brain. One might be a LangGraph service you run. The other might be a partner’s agent you do not get to rewrite. They still need a way to meet.
An Agent Card is the business card: what this employee can do, how to reach them. You do not discover a coworker by reading their source. You read the card. Task-based communication is the job ticket, not a single ping. Real work takes time. The ticket has a state: accepted, working, done, failed. A request/response chat is a bad fit for “research this account and come back after lunch.”
Framework-agnostic is the point of the standard. If both sides must be CrewAI, you do not have a protocol. You have a club. A2A is the clubhouse door that does not check your framework hoodie. Google’s Agent Development Kit ships with this door first-class, which is useful and not the same as “only Google may walk through.”
MCP versus A2A, in the sentence you should memorize: MCP connects an agent to tools and data. A2A connects agents to each other. Production systems often need a calculator and a colleague. Using one protocol for both jobs makes a mess, the way you should not send inter-office mail through the power outlet.
Map the office.
- An Agent Card is the business card.
- A task is a job ticket with a life, not a single ping.
- Framework-agnostic means the hoodie does not matter.
- MCP is the power outlet for tools.
- A2A is the mail between employees.
- ADK is one kit that already prints the business cards.
orchestrator reads Agent Card
orchestrator assigns a task
specialist works, updates state, returns a resultThat is delegation. It is slower to explain than a function call and closer to how companies already work.
A2A exists because multi-agent demos kept assuming every agent was in one process and one vendor’s SDK. The moment a second company shows up, you need cards and tickets. You do not need them for a single bot with three tools. You need them when the colleague is not your code.
Mental model: business cards and job tickets between employees. Tools stay on the MCP outlet. Colleagues get A2A.
You can explain the page if that one-sentence split is easy, and if you know a task is allowed to take longer than one HTTP round trip.
