Open Protocols for Agent Interoperability Part 4: Inter-Agent Communication on A2A

Welcome to Part 4 of our blog series on Open Protocols for Agent Interoperability where we will cover the Agent-to-Agent (A2A) protocol, AWS’ involvement with the Linux Foundation-based open standard, and our support of A2A in the Strands Agents SDK. Here is what we’ve covered so far:

• Part 1: How the Model Context Protocol (MCP) facilitates inter-agent communication and how AWS has been working on MCP specification enhancements to better support inter-agent communication.
• Part 2: Details on recent MCP specification updates around Authentication.
• Part 3: How to build inter-agent systems with the new Strands Agents SDK and MCP.

Standard protocols are the primary way to connect networked services. Often multiple protocols exist to address different ways of making network connections. In the networking layer, two primary protocols exist: TCP and UDP. Each are suited to specific needs and neither is universal. The same is true when connecting AI agents. In part 4 of our inter-agent communication blog series we will cover what A2A is, how to use it for communicating between agents, and the ways AWS is supporting customers building systems with A2A.

MCP was initially created to connect agents to tools but can also be used to connect agents to agents. A2A was created to connect agents to agents and can also be used in conjunction with MCP for agents to communicate with tools. Which protocol you use for agent-to-agent connections depends on your needs. AWS supports both protocols, enabling customers using MCP, A2A, or a mixture of the two to deploy their code on AWS.

As the inter-agent protocols and the frameworks around them evolve, likely they will become like TCP & UDP where most developers focus more on building their agents instead of underlying protocols. The first step towards that is for agent frameworks to support the protocols and build ecosystems around them. At AWS we’ve taken that first step by joining the A2A standard community and adding support for A2A in our open source Strands Agents SDK. Swami Sivasubramanian, VP of AWS Agentic AI, summarizes this effort:

At AWS, we believe agentic AI will be critical to nearly any customer experience. We welcome A2A joining The Linux Foundation and envision it will create broader opportunities for anyone building AI-powered apps. We intend to support the community with project contributions, and access to the broadest and deepest set of agentic frameworks, protocols, and services.

In the same way we are helping evolve MCP, we are also helping evolve A2A to meet the needs of our customers. There are a number of areas we plan to work on so that A2A works great on AWS, including Amazon Bedrock AgentCore support, A2A protocol extensions for ephemeral task storage and SigV4, improved multi-task management, and improvements to the Java A2A SDK.

A2A Overview

The A2A protocol addresses a critical challenge in the AI landscape. It enables AI agents built on diverse frameworks, and by different companies running on separate servers, to communicate and collaborate effectively — as agents, not just as tools. A2A represents a significant advancement in creating interoperable AI systems that can work together across organizational boundaries. The protocol is backed by a growing ecosystem of partners including over 50 technology companies such as Google, Atlassian, Confluent, Salesforce, SAP, and MongoDB.

Before A2A, organizations faced significant challenges in deploying multi-agent AI systems at scale. Without a standardized protocol, each agent pairing required custom integration code, leading to excessive development overhead and maintenance complexity. This created siloed AI systems where specialized agents couldn’t easily share their capabilities or coordinate on complex tasks. The protocol gives agents a common language that allows them to retain their autonomy and special skills while cooperating – agents communicate as peers, not as mere tools. This distinction is crucial as it enables agents to engage in sophisticated back-and-forth interactions, negotiate task requirements, and maintain their independent decision-making capabilities while working toward shared goals.

For AWS customers, A2A offers several compelling features that align with enterprise requirements. The protocol enables enterprise capabilities including secure agent discovery through standardized agent cards, authentication and authorization mechanisms for controlled access, support for multiple communication modalities (text, forms, media), and the ability for agents to collaborate on long-running tasks without exposing their internal state or implementation details.

A2A addresses the unique challenges of multi-agent collaboration through features that enable sophisticated workflows, handling complex, real-world business processes with the observability and control that production environments require. In particular, it offers support for agent cards, structured tasks, multiple transport options, and authentication/authorization primitives.

Agent Cards

Effective multi-agent communication requires agents to discover and understand each other’s capabilities. A2A facilitates this through Agent Cards — metadata documents that capture the semantic meaning of what each agent can do, how it prefers to work, and what kinds of tasks it excels at. Agent cards allow other agents to make intelligent decisions about when and how to collaborate. Agent Cards also describe the authentication/authorization requirements of an agent, and support progressively increasing exposed capabilities after authentication, using Authenticated Extended Agent Cards.

Structured Task Execution

Agents work together to solve problems by leveraging tasks to structure their communications; they organize their messages into intelligent work units that carry context, track progress, and store output artifacts. Through tasks, agents can reference previously-generated artifacts, understand dependencies between tasks in a workflow, and make informed decisions based on the complete conversation history. Tasks support both sequential and parallel execution for complex workflows. Agents can spawn multiple follow-up tasks simultaneously and create chains of dependent operations. This gives application developers the flexibility to model real-world business processes.

By leveraging task and context IDs, applications can track task provenance, following a chain of tasks to its root to recover information about how an output was created. This improves observability by giving agents the ability to emit rich operation logs for debugging and auditing.

Diverse Transport Options

A2A empowers application developers by supporting three equally-capable core protocols: JSON-RPC 2.0, gRPC, and REST. This allows developers to choose the transport that best matches a team’s expertise, existing infrastructure, and performance requirements. For long-running operations, A2A enhances each transport with Server-Sent Events (SSE) for streaming and webhook-based push notifications. Developers get intuitive options to handle asynchronous task updates and real-time progress monitoring without complex polling logic.

A2A Security

Enterprise-grade security is a non-negotiable requirement for agentic systems. A2A enables robust security architectures by providing support for several authentication schemes; including OAuth 2.0, OpenID Connect, and mTLS, allowing organizations to integrate agents with their existing identity infrastructure, while skill-specific authorization metadata and secondary authentication support enables fine-grained access control policies that can be enforced at the application level.

A2A’s decision to keep agents opaque relative to each other supports zero-trust architectures by treating each agent as an independent security boundary, and the protocol’s support for task auditing provides the foundation for comprehensive security monitoring and compliance reporting.

Inter-Agent with Strands Agents & A2A

The unique features of A2A make it a great fit for agent framework interoperability. A number of open source agent frameworks are already supporting it. The open source Strands Agents SDK recently added support for A2A so agents can easily communicate with other agents.

Strands Agents takes a model-driven approach to building and running AI agents in just a few lines of code. Strands scales from simple to complex agent use cases, and from local development to deployment in production. Multiple teams at AWS already use Strands for their AI agents in production, including Amazon Q Developer, AWS Glue, and VPC Reachability Analyzer.

With the built-in A2A support in Strands Agents you can easily expose an agent as an A2A server and communicate from a Strands Agent to other A2A agents. To illustrate this let’s walk through an example of a Human Resources (HR) agent which can answer questions about employees. To do this you could imagine the HR agent communicating with a number of other agents like an employee data agent, an Enterprise Resource Planning (ERP) agent, a performance agent, goal agent, etc. For this example, let’s start with a basic architecture where a REST API exposes access to an HR agent which connects to an Employee Info agent: Architecture of the inter-agent system containing two agents (HR & Employee Info), connected using A2A.

Architecture of the inter-agent system containing two agents (HR & Employee Info), connected using A2A.

Note: The complete, working version of the following example is available in our Agentic AI samples repo.

Our Employee Info agent uses Amazon Bedrock and an MCP tool to get the employee data (see the full code for those aspects):

employee_agent = Agent(
    model=bedrock_model,
    name="Employee Agent",
    description="Answers questions about employees",
    tools=tools,
    system_prompt="you must abbreviate employee first names and list all their skills"
)

a2a_server = A2AServer(agent=employee_agent, host=urlparse(EMPLOYEE_AGENT_URL).hostname, port=urlparse(EMPLOYEE_AGENT_URL).port)

if __name__ == "__main__":
    a2a_server.serve(host="0.0.0.0", port=8001)

provider = A2AClientToolProvider(known_agent_urls=[EMPLOYEE_AGENT_URL])

agent = Agent(model=bedrock_model, tools=provider.tools)

curl -X POST --location "http://something.us-east-1.elb.amazonaws.com/inquire" \
-H "Content-Type: application/json" \
-d '{"question": "list employees that have skills related to AI programming"}'

Here are the employees with skills related to AI programming:

1. A. Rosalez - Machine Learning, REST API
2. E. Owusu - DevOps, Machine Learning, Python
3. J. Doe- Machine Learning, JavaScript
4. K. Mensah - REST API, Kubernetes, Machine Learning, Node.js
5. M. Rivera - AWS, Kubernetes, GraphQL, Machine Learning
6. M. Major - MongoDB, Angular, Kotlin, Machine Learning, REST API
7. C. Salazar - React, Machine Learning, SQL, Kotlin
8. N. Wolf - SQL, Machine Learning, Docker, DevOps, Git

If you need more detailed information about any of these employees or require further assistance, please let me know!