Agent-to-agent · Google · Linux Foundation, 2025
Agent-to-Agent Protocol
Enables peer-to-peer task delegation between autonomous agents across organisational boundaries. The multi-agent coordination protocol.
Abbreviation: A2AThe Agent-to-Agent Protocol is the multi-agent coordination layer of the agentic commerce stack. Developed by Google and hosted by the Linux Foundation, A2A enables peer-to-peer task delegation between autonomous agents across organisational boundaries.
Where MCP connects agents to tools, A2A connects agents to each other. This distinction matters because the emerging agentic commerce architecture is not a single-agent system. A consumer's personal shopping agent may need to delegate a subtask to a merchant's specialist agent, which in turn may delegate a fulfilment query to a logistics agent. A2A defines how these delegation chains work.
A2A is the least mature of the six protocols in terms of production deployment, but it addresses the most structurally important coordination problem: how do agents from different organisations communicate, delegate, and maintain accountability across trust boundaries? Without A2A, multi-agent commerce requires bespoke point-to-point integrations between every agent pair.
The protocol includes horizontal task delegation, cross-organisational agent communication with defined trust boundaries, task handoff with context preservation, and responsibility attribution. These capabilities are essential for B2B agentic commerce, procurement workflows, and any scenario involving multi-party agent chains.
How does one agent delegate a task to another specialist agent?
What A2A provides
Horizontal task delegation: one agent delegates a subtask to a specialist agent
Cross-organisational agent communication with defined trust boundaries
Task handoff with context preservation: the receiving agent inherits sufficient context to complete the task
Responsibility attribution: clear record of which agent performed which action
Complements MCP (which connects agents to tools) by connecting agents to each other
Before you begin
The following must be in place before starting A2A integration. Missing prerequisites are the most common cause of delayed or failed protocol deployments.
Clear definition of which tasks your agents will delegate vs handle internally
Agent identity and capability advertisement infrastructure
Trust boundary definitions for cross-organisational agent communication
Logging and attribution infrastructure for multi-agent task chains
What goes wrong
These are the failure modes the AXD Institute has observed across early A2A implementations. Each includes the root cause and the recommended mitigation.
Unbounded delegation chains
without clear delegation depth limits, agents can create circular or excessively deep delegation chains that consume resources without completing tasks.
Context loss during handoff
insufficient context transfer between agents results in the receiving agent requesting information the delegating agent already had, creating latency and poor user experience.
Attribution gaps
when multiple agents contribute to a transaction, unclear responsibility attribution creates dispute resolution challenges.
Step-by-step walkthrough
A sequenced implementation guide for A2A. Each step includes the action, the rationale, and the validation criteria for completion.
Define delegation boundaries
Before implementing A2A, define which tasks your agents will delegate to external agents and which they will handle internally. This is a business decision, not a technical one.
- •Map your current agent workflows and identify tasks that require capabilities your agents do not have.
- •For each delegatable task, define: what context must be transferred, what authority is being delegated, and what the expected response format is.
- •Define delegation depth limits. Without explicit limits, agents can create circular or excessively deep delegation chains.
- •Document trust boundary definitions for cross-organisational agent communication. Which external agents are trusted for which task types?
Agent identity and capability advertisement
Implement the infrastructure that allows your agents to advertise their capabilities to other agents and discover the capabilities of external agents.
- •Define your agent's capability profile: what tasks can it accept from external agents?
- •Implement capability advertisement using A2A's discovery mechanism.
- •Configure trust levels for incoming delegation requests. Not all external agents should be trusted equally.
- •Set up agent registry entries so external agents can discover your agent's capabilities.
Task handoff and context preservation
Implement the task handoff mechanism that ensures receiving agents inherit sufficient context to complete delegated tasks without redundant information requests.
- •Define context transfer schemas for each delegatable task type. Insufficient context transfer causes the receiving agent to request information the delegating agent already had.
- •Implement context serialisation that preserves all relevant state without exposing sensitive internal data.
- •Build context validation on the receiving side - verify that incoming context meets the minimum requirements before accepting the delegation.
- •Implement graceful degradation for partial context - if some context is missing, the receiving agent should request only the missing elements rather than rejecting the entire delegation.
Attribution and audit infrastructure
Implement logging and attribution infrastructure that maintains a clear record of which agent performed which action in multi-agent task chains.
- •Implement end-to-end task chain logging that records every delegation, handoff, and completion event.
- •Assign unique task chain identifiers that persist across delegation boundaries.
- •Build attribution reports that can answer: which agent initiated this action, which agents contributed, and which agent completed the final step?
- •For regulated industries, ensure the audit trail meets regulatory requirements for transaction accountability.
Testing and production deployment
Test multi-agent delegation chains in a controlled environment before production deployment.
- •Test delegation chains with known partner agents in a sandbox environment.
- •Verify context preservation across delegation boundaries - does the receiving agent have everything it needs?
- •Test delegation depth limits - verify that circular delegation chains are detected and terminated.
- •Test attribution accuracy - verify that audit trails correctly record the full delegation chain.
- •Deploy to production with monitoring for: delegation success rate, context completeness, delegation chain depth, and attribution accuracy.
Related metrics, frameworks, and essays
AXD Metrics Standard KPIs
AXD Practice Frameworks