AWS Logo
Menu
Exposing Amazon Bedrock Agents with the Agent2Agent (A2A) Protocol

Exposing Amazon Bedrock Agents with the Agent2Agent (A2A) Protocol

The Agent2Agent (A2A) Protocol enables AI agents to communicate across different platforms. This guide shows how to implement an Amazon Bedrock Agent using A2A, allowing it to work with other A2A-compliant agents. By connecting Bedrock Agents through A2A, we can create powerful multi-agent systems for complex workflows.

bedrockai-agents
Eryan Ariobowo
Amazon Employee
Published Jun 3, 2025

Understanding the A2A Protocol

Before diving into the implementation, let's briefly understand what the A2A protocol is and why it matters.
The A2A protocol is an open standard that enables different AI agents to communicate with each other regardless of their underlying implementation. It provides a common language for agents to:
  • Discover each other's capabilities
  • Send and receive messages
  • Execute tasks
  • Stream responses
  • Maintain conversation context
This interoperability is crucial for building complex AI systems where specialized agents need to collaborate to solve problems.

Project goal

In this article our goal is to create an A2A server that wraps an existing Amazon Bedrock Agent, exposing it through the A2A protocol. The server will:
  1. Define an Agent Card that describes the Bedrock Agent's capabilities
  2. Handle incoming A2A requests and translate them to Bedrock Agent API calls
  3. Process responses from the Bedrock Agent and format them according to the A2A protocol
  4. Support both synchronous and streaming interactions
The implementation consists of three main components:
  1. BedrockAgentWrapper: Handles communication with the Amazon Bedrock Agent API
  2. BedrockAgentTaskManager: Manages A2A tasks and translates between A2A protocol and Bedrock Agent API
  3. A2A Server: Exposes the agent's capabilities via HTTP endpoints

Getting Started: Setting Up Your Development Environment

Let's start by setting up our development environment and creating the necessary files for our Bedrock Agent wrapper. Follow these steps to get started:

Clone the A2A Repository

First, clone the A2A repository to get access to the core protocol implementation and sample code:

Create a Directory for Your Bedrock Agent Wrapper

Create a new directory for your Bedrock Agent wrapper in the samples directory:

Basic File Structure

We will create the essential files we'll need for our implementation:
  • __init__.py: Makes the directory a Python package
  • __main__.py: Entry point for running the server
  • bedrock_agent_wrapper.py: Wrapper for the Bedrock Agent API
  • task_manager.py: Manages A2A tasks and translates between A2A and Bedrock
  • server.py: Server implementation for the A2A protocol
  • run.py: Helper script to run the server
  • pyproject.toml: Project dependencies and metadata
  • .env: Environment variables config file

Set Up Project Dependencies

Create a pyproject.toml file with the necessary dependencies:

Create the Environment Variables Template

We need to set up our environment with the necessary dependencies and configuration. The project uses a .env file to store configuration parameters, making it easy to adapt for different Bedrock Agents.
Here's what a typical .env file looks like:
This configuration-driven approach allows you to easily switch between different Bedrock Agents by simply updating the environment variables, without changing any code.

Implementing the Bedrock Agent Wrapper

Now, let's implement the core components of our Bedrock Agent wrapper.

The Bedrock Agent Wrapper

The BedrockAgentWrapper class is responsible for communicating with the Amazon Bedrock Agent API. It provides a clean interface for the rest of the application to interact with Bedrock Agents without worrying about the underlying API details.
The wrapper abstracts away the complexities of the Bedrock Agent API, providing a simple invoke method that takes a user query and returns the agent's response. This makes it easy to integrate with the A2A protocol.

Task Management

The BedrockAgentTaskManager class extends the A2A SDK's InMemoryTaskManager to handle task lifecycle management. It's responsible for:
  1. Validating incoming requests
  2. Invoking the Bedrock Agent
  3. Managing task state
  4. Formatting responses according to the A2A protocol
The task manager handles the translation between A2A protocol concepts (like tasks, artifacts, and messages) and the Bedrock Agent API. This ensures that the Bedrock Agent can be seamlessly integrated into the A2A ecosystem.

Server Configuration

The main entry point for our application is the __main__.py file, which sets up the A2A server with the appropriate configuration:
The server configuration is highly customizable, allowing you to define:
  1. The agent's name, description, and provider information
  2. The skills and capabilities of the agent
  3. The supported input and output modes
  4. 4The host and port for the server

Making the Code Generic

One of the key strengths of this implementation is its flexibility. By using environment variables and command-line arguments, we can make the code generic enough to work with any Bedrock Agent without modification.
If you want to make it more generic, here's how:
  1. Dynamic Skill Discovery: Instead of hardcoding the agent's skills, we could query the Bedrock Agent API to discover its capabilities and generate the A2A skills dynamically.
  2. Customizable Agent Card: Allow users to provide a custom agent card template in the .env file, which can be merged with the dynamically discovered capabilities.
  3. Support for Different Authentication Methods: Add support for different AWS authentication methods, such as IAM roles, AWS profiles, or temporary credentials.
  4. Content Type Negotiation: Enhance the content type handling to support more formats beyond plain text, such as JSON, Markdown, or HTML.

Running the Server

To run the server, you simply need to:
  1. Set up your .env file with the appropriate Bedrock Agent configuration
  2. Install the dependencies
  3. Run the server
The server will start and listen for connections on the specified host and port. You can then interact with it using any A2A client.

Interacting with the Server

Once the server is running, you can interact with it using any A2A-compliant client. The A2A repository includes a CLI client that you can use for testing:
This will start a CLI interface where you can send messages to your Bedrock Agent through the A2A protocol.

Conclusion

Exposing Amazon Bedrock Agents through the A2A protocol opens up exciting possibilities for building complex, collaborative AI systems. By following the approach outlined in this article you can make your Bedrock Agents interoperable with other A2A-compliant agents, enabling them to work together to solve complex problems.
The implementation we've explored is highly flexible and can be adapted to work with any Bedrock Agent by simply updating the configuration in the .env file. This makes it easy to integrate your existing Bedrock Agents into the A2A ecosystem without significant code changes.
As the A2A protocol continues to evolve, we can expect even more powerful integration possibilities between different AI agent frameworks. By adopting this open standard, we're taking a step toward a future where AI agents can seamlessly collaborate, regardless of their underlying implementation.

 

Any opinions in this post are those of the individual author and may not reflect the opinions of AWS.

Comments