A2A — Agent-to-Agent Communication¶
Last reviewed: October 2026
Sources: the official A2A protocol specification (a2a-protocol.org); verify against it before an interview. Content was rephrased for compliance with licensing restrictions.
What's changed recently
- A2A is a Linux Foundation project now. Google created it and donated it in mid-2025. In August 2025 IBM's ACP (Agent Communication Protocol) merged into A2A instead of competing with it.
- v1.0 is the first stable specification (the Linux Foundation marked A2A's first year in April 2026). It adds signed Agent Cards, multi-tenancy, and modernized security flows.
- Multiple protocol bindings. A2A defines JSON-RPC, gRPC, and HTTP+JSON/REST bindings, with SSE streaming and webhook push notifications for long tasks.
- Platform support. Azure AI Foundry / Copilot Studio and Amazon Bedrock AgentCore Runtime support A2A, and more than 150 organizations back it.
As systems move from a single agent to teams of agents, they need a way to talk to each other: delegate tasks, share results, and coordinate. A2A is the protocol/pattern layer for that — complementary to MCP (which connects an agent to tools/data).
MCP vs A2A (don't confuse them)¶
flowchart LR
subgraph Agent
A[Agent]
end
A -- MCP --> T[Tools / data / resources]
A -- A2A --> B[Another agent]
B -- A2A --> C[Specialist agent]
| MCP | A2A | |
|---|---|---|
| Connects | Agent → tools/data | Agent → agent |
| Purpose | Give an agent capabilities | Let agents delegate & coordinate |
| Analogy | "USB-C for tools" | "Agents calling colleagues" |
Multi-agent coordination patterns¶
| Pattern | Idea |
|---|---|
| Supervisor / orchestrator | One agent plans and delegates to specialists |
| Peer / hand-off | Agents pass a task along a pipeline (research → write → review) |
| Blackboard | Agents read/write a shared state/store |
| Marketplace / bidding | Agents claim tasks they're suited for |
What an A2A exchange needs¶
- Identity & discovery — who is this agent, what can it do (a capability card/manifest).
- Task messages — structured request + inputs + expected output.
- Status & results — progress, completion, errors, artifacts.
- Trust & auth — agents must authenticate; least privilege applies.
The A2A protocol (created by Google, now governed by the Linux Foundation) standardizes these pieces. Frameworks like LangGraph, CrewAI, and AutoGen implement multi-agent coordination inside one system; A2A is for agents that talk across system, team, or vendor boundaries.
| A2A concept | What it is |
|---|---|
| Agent Card | JSON metadata at a well-known URL: identity, skills, endpoint, supported bindings, and security schemes. It can be signed. |
| Task | The unit of delegated work, with a lifecycle: e.g. working, input-required, auth-required, then a terminal completed / failed / canceled / rejected |
| Message / Part | A turn from the user or agent role, made of Parts (text, file reference, structured data) |
| Artifact | An output the remote agent produces, also built from Parts |
| Streaming / push | SSE for live updates; webhooks for long-running tasks |
The remote agent stays opaque: you see its card, task status, and artifacts, not its prompts, tools, or memory. That is the main difference from MCP, where the client sees every tool's schema.
When to go multi-agent¶
Default to single-agent. Introduce A2A/multi-agent when one agent's scope, tools, or context become unreliable — e.g. distinct specialties (retrieval vs coding vs review). Coordination adds latency, cost, and new failure modes, so justify it.
Interview deep dive¶
Talking points¶
- "MCP connects an agent to tools; A2A connects agents to each other."
- "Start single-agent; go multi-agent only when scope demands it."
- "A2A needs identity, discovery, structured tasks, and trust."
Scenario questions¶
When would you split one agent into multiple communicating agents?
When responsibilities/tools become too broad for reliable single-agent behavior — e.g. a planner delegating to a researcher, a coder, and a reviewer. Use a supervisor pattern; keep each agent's scope tight.
How is A2A different from just calling a function?
A2A treats the other party as an autonomous agent with its own reasoning and capability discovery, exchanging tasks/results — not a deterministic function call. It needs identity, negotiation, and trust between agents.
Rapid-fire¶
| Q | A |
|---|---|
| MCP vs A2A? | Agent→tools vs agent→agent |
| Common pattern? | Supervisor delegating to specialists |
| A2A needs? | Identity, discovery, task messages, trust |
| Default? | Single-agent; multi-agent only when justified |
| Who governs A2A? | Linux Foundation (ACP merged in, Aug 2025); v1.0 is stable |
| Agent Card? | Discoverable, optionally signed, metadata: skills, endpoint, auth schemes |
How interviewers probe this¶
Walk me through one A2A delegation end to end.
A strong answer covers: discovery (fetch and verify the Agent Card, check its signature, pick a supported binding), auth against the security scheme the card declares, sending a Message that creates a Task, following state changes (including input-required / auth-required interruptions) over SSE or push notifications, and collecting Artifacts. It also says the remote agent is opaque, so you depend on its contract, not its internals.
How do you secure agent-to-agent calls across an org boundary?
Verify identity (signed Agent Cards, mTLS or OAuth/OIDC per the declared scheme), use least-privilege scopes, and decide whether the call carries the end user's identity (token exchange) or the calling agent's identity. Treat everything the remote agent returns as untrusted input, because it can carry prompt injection. Rate-limit and audit every task. OWASP's Agentic Top 10 lists insecure inter-agent communication (ASI07) as its own risk.
MCP or A2A for this integration? Where do you draw the line?
MCP fits when the other side is a tool or data source with a schema and predictable behavior. A2A fits when the other side is an autonomous agent owned by another team or vendor, with its own reasoning, long-running tasks, and a need for clarification. One agent is often both: an A2A server to its callers and an MCP client to its own tools.
A delegated task runs for an hour and needs human input halfway. How do you design it?
Model it as a Task that moves to input-required. Use push notifications instead of holding a stream open, store orchestrator state durably (checkpointer), make resume idempotent, and set timeouts and cancellation. Show the pending question to a human through your own approval workflow.
What breaks first in a multi-agent system in production, and how do you contain it?
Cascading failures and loops between agents, lost context at hand-offs, cost multiplying with each delegation, and unclear accountability. Contain them with delegation-depth limits, per-task budgets, trace-context propagation across agents, contract tests against each Agent Card, and evaluation of the whole trajectory, not each agent alone.