Agent Collaboration: Strands Agents, MCP, and the Agent2Agent Protocol
This blog post provides an overview of how Strands Agents, an open-source SDK for building and running AI agents, can work with Agent2Agent (A2A) protocol for multi-agent applications.
Jagdeep Singh Soni
Amazon Employee
Published Jun 4, 2025
The world of AI agents is rapidly evolving, promising increased productivity and automation across various tasks. However, to truly maximize the benefits of agentic AI, these agents need to be able to collaborate effectively, even when built by different teams or using different technologies. This blog post explores how Strands Agents, a powerful open source SDK, fits into this vision, leveraging Model Context Protocol (MCP) tools today and looking towards seamless interoperability through the Agent2Agent (A2A) protocol in the future.
Strands Agents is an open source SDK designed to simplify the process of building and running AI agents. It takes a model-driven approach, empowering state-of-the-art models to handle tasks like planning, chaining thoughts, calling tools, and reflecting, often with just a prompt and a list of tools. This approach leverages the advanced reasoning and tool use capabilities of modern Large Language Models (LLMs). Strands supports various models from providers like Amazon Bedrock, Anthropic, Meta, and others, and can run in diverse environments.
At its core, a Strands agent is defined by a model, tools, and a prompt. The agent operates in a loop, using the model to dynamically direct its steps and interact with tools to complete the specified task.
At its core, a Strands agent is defined by a model, tools, and a prompt. The agent operates in a loop, using the model to dynamically direct its steps and interact with tools to complete the specified task.
A key aspect of any effective agent is its ability to interact with the outside world, accessing data and performing actions. This is where tools come in. Strands Agents are designed to easily integrate with tools, including those exposed via the Model Context Protocol (MCP).
MCP is an open protocol that standardizes how applications provide context to LLMs. It acts like a universal connector, allowing AI models to plug into various data sources and tools in a standardized way. MCP follows a client-server architecture, where an application (like a Strands agent, acting as an MCP Client) connects to multiple MCP Servers, each exposing specific capabilities securely accessing local data or remote services.
Strands provides flexible tool support. You can easily turn any Python function into a tool using a decorator. For example, defining a tool in Strands looks like this:
More importantly for standardized access, Strands can load tools exposed by an MCP server using the
MCPClient. For example, you can use an MCPClient to connect to an MCP server. This integration allows Strands agents to leverage a growing ecosystem of pre-built integrations available via MCP, enhancing their ability to access diverse data and capabilities securely.While MCP focuses on providing tools and context to an agent, another protocol addresses the challenge of agents needing to collaborate with each other. This is the Agent2Agent (A2A) protocol.
A2A is an open standard designed to enable seamless communication and collaboration between AI agents. Its primary goal is to enable AI agents, even if they were built by different vendors or in different frameworks, to communicate with each other, securely exchange information, and coordinate actions. A2A aims to break down silos and allow agents to collaborate dynamically in a multi-agent ecosystem. This interoperability is seen as crucial for realizing the full potential of collaborative AI agents and automating complex enterprise workflows.
Strands Agents recognizes the importance of agent-to-agent communication. Strands support for the Agent2Agent (A2A) protocol for multi-agent applications is coming soon.
While full, seamless interoperability between Strands Agents and other A2A-compatible agents is coming soon, Strands agents can currently be integrated by implementing the A2A
AgentExecutor interface. This allows a Strands agent to execute queries received within an A2A context and return results. Integrating a Strands agent with the A2A protocol involves implementing the A2A
AgentExecutor interface. A common pattern is to wrap the core Strands agent logic within a class designed for A2A interaction, such as a StrandsAgent wrapper class and a StrandsAgentExecutor class.The
StrandsAgent class typically initializes and holds the core Strands Agent instance, defining how it can be invoked. It can provide methods for both synchronous invocation and streaming interactions.The
StrandsAgentExecutor class then implements the A2A AgentExecutor interface, using the StrandsAgent wrapper internally. The execute method is a core part of this interface, where the Strands agent is invoked and its results are communicated back via the A2A EventQueue.The combination of Strands' agent building capabilities and the interoperability offered by A2A unlocks significant possibilities for building complex, multi-agent systems.
Customers using Strands will be able to:
- Break Down Silos: Connect their Strands agents with specialized agents built on other frameworks or by different vendors, as long as those agents support A2A.
- Enable Complex Collaboration: Orchestrate Strands agents to work alongside other A2A-compatible agents to tackle tasks that no single agent could handle alone.
- Build Richer Agentic Applications: Combine the strengths of various agents – for example, a Strands agent could coordinate tasks with an agent built using another framework like LangGraph. Within Strands itself, developers can already apply advanced techniques for multi-agent systems using built-in "multi-agent tools" like the workflow, graph, and swarm tools.
The vision is a future where agents, regardless of how they were built, can discover each other's capabilities, securely exchange information, and coordinate actions. Strands Agents, with its focus on ease of use and production readiness, is poised to play a key role in this interoperable ecosystem, leveraging MCP for tools and integrating with A2A for agent-to-agent communication.
For detail guide on A2A setup, you can check A2A QuickStart Tutorial and samples.
To begin integrating Strands Agents with A2A, you can follow these general steps outlined below:
To begin integrating Strands Agents with A2A, you can follow these general steps outlined below:
- Install dependencies: You'll need the
strandsanda2alibraries.
- Create your Strands agent implementation: Define your agent logic, potentially within classes like
StrandsAgentandStrandsAgentExecutor.
- Configure Strands Agent with A2A server
- Start the A2A server: This makes your Strands-based A2A agent available.
- Test with an A2A client: Use an A2A client implementation to interact with your agent.
These steps provide a basic pathway to setting up and testing a Strands agent integrated as an A2A endpoint.
By integrating with the MCP for tool access and embracing the upcoming Agent2Agent protocol for seamless inter-agent communication, Strands empowers developers to build complex, multi-agent systems that can tackle tasks beyond the capabilities of any single agent.
Strands Agents, with its focus on ease of use and production readiness, is poised to play a key role in this emerging interoperable ecosystem. The future envisioned is one where AI agents, much like human teams, can discover each other's capabilities, securely exchange information, and coordinate their actions to solve problems more effectively.
These steps provide a basic pathway to setting up and testing a Strands agent integrated with A2A.
Jagdeep Singh Soni is a Senior Partner Solutions Architect at AWS based in the Netherlands. He uses his passion for generative AI to help customers and partners build generative AI applications using AWS services. Jagdeep has 15 years of experience in innovation, experience engineering, digital transformation, cloud architecture, and ML applications.
Ajeet Tewari is a Senior Solutions Architect for Amazon Web Services. He works with enterprise customers to help them navigate their journey to AWS. His specialties include architecting and implementing scalable OLTP systems and leading strategic AWS initiatives.
Any opinions in this post are those of the individual author and may not reflect the opinions of AWS.