The headline most teams have been waiting for is here: agent-to-agent protocol support in Amazon Bedrock AgentCore Runtime. Agents hosted on the runtime can now discover and call one another using the open A2A (Agent-to-Agent) protocol — across frameworks and even across vendors. This post explains what A2A is, what AgentCore’s support adds, and how to build multi-agent systems on it.
What is the A2A protocol?
A2A is an open protocol for communication between autonomous agents. Where MCP (Model Context Protocol) standardises how an agent talks to tools, A2A standardises how an agent talks to other agents. It defines how an agent advertises its capabilities (via an “agent card”), how another agent discovers it, and how they exchange tasks and results — regardless of what framework or model each one is built on.
The two protocols are complementary: an agent uses MCP to reach its tools and A2A to delegate to peer agents. Together they are becoming the interoperability layer for the agentic ecosystem.
What AgentCore Runtime's A2A support adds
- Native protocol support. Agents deployed on the AgentCore Runtime can expose and consume A2A endpoints without you building the transport yourself.
- Framework-agnostic interop. A LangGraph agent can call a CrewAI or Strands agent — and vice versa — because they speak a shared protocol rather than a bespoke integration.
- Discovery. Agents publish capability metadata so collaborators can find the right agent for a task at runtime instead of hard-wiring addresses.
- Isolation preserved. Each agent still runs in its own isolated session, so A2A collaboration does not weaken the runtime’s security boundaries.
What multi-agent A2A unlocks
A2A makes specialised, composable agents practical. Instead of one monolithic agent that tries to do everything, you build focused agents — a research agent, a SQL agent, a reporting agent — and let them call each other. A coordinator agent can decompose a goal and delegate sub-tasks to whichever specialist is best suited, including agents owned by other teams or vendors.
This is the same decomposition that makes an agentic pipeline tractable: small, well-scoped units that compose into something larger and more capable than any single agent.
Building with A2A on AgentCore
- Deploy each agent to the AgentCore Runtime as usual, enabling its A2A endpoint.
- Publish capabilities so other agents can discover what each one does.
- Wire delegation — have a coordinator agent call specialists over A2A, passing tasks and receiving results.
- Secure the calls with AgentCore Identity so each inter-agent request carries a scoped, auditable identity.
- Observe the whole graph — trace requests as they hop between agents so a multi-agent flow stays debuggable.
Governance matters more with many agents
Multi-agent systems multiply the attack surface and the ways things can go wrong: a prompt injected into one agent can propagate through A2A calls, and a loop between agents can run up cost fast. Apply scoped identities to every inter-agent call, set rate and cost limits, and trace the full call graph. Our agent runtime security guide covers these controls in depth.
Where Orchestra fits
A2A handles agent-to-agent calls at runtime. Orchestra handles the layer above: coordinating agents with the data pipelines and jobs around them, enforcing the order things run in, tracking lineage across the whole graph, and recovering when a step fails. A2A lets agents talk; orchestration makes the resulting system dependable.
Conclusion
Agent-to-agent protocol support in Amazon Bedrock AgentCore Runtime brings open, framework-agnostic interoperability to multi-agent systems on AWS. Agents discover and delegate to one another over A2A while keeping their isolation — the foundation for building composable specialist agents instead of monoliths. Pair it with strong identity, observability and orchestration to keep those systems secure and reliable.
