# Protocols


AI agents require standardized communication protocols to interact with other agents and services. Organizations implementing agent architectures face significant challenges around interoperability, vendor independence, and future-proofing their investments.

This section helps you navigate the agent-to-agent protocol landscape with a focus on open standards that maximize flexibility and interoperability. (For information about agent-to-tool protocols, see [Tool integration strategy](tool-integration-strategy.md) later in this guide.)

This section highlights the Model Context Protocol (MCP), an open standard originally developed by Anthropic in 2024. Today, AWS actively supports MCP through contributions to the protocol's development and implementation. AWS is collaborating with leading open-source agent frameworks, including LangGraph, CrewAI, and LlamaIndex, to shape the future of inter-agent communication on the protocol. For more information, see [Open Protocols for Agent Interoperability Part 1: Inter-Agent Communication on MCP](https://aws.amazon.com/blogs/opensource/open-protocols-for-agent-interoperability-part-1-inter-agent-communication-on-mcp/) (AWS Blog).

**In this section:**
+ [Why protocol selection matters](protocol-selection.md)
+ [Agent-to-agent protocols](agent-to-agent-protocols.md)
+ [Selecting agentic protocols](selecting-agentic-protocols.md)
+ [Implementation strategy for agentic protocols](implementation-strategy.md)
+ [Getting started with MCP](getting-started-with-mcp.md)
+ [Getting started with A2A](getting-started-a2a.md)

# Why protocol selection matters


Protocol selection fundamentally shapes how you can build and evolve your AI agent architecture. By choosing protocols that support portability between agent frameworks, you gain the flexibility to combine different agent systems and workflows to meet your specific needs.

Open protocols enable you to integrate agents across multiple frameworks. For example, use LangChain for rapid prototyping and implement production systems with Strands Agents, communicating through a common protocol, such as MCP or the Agent2Agent (A2A) protocol. This flexibility reduces dependency on specific AI providers, simplifies integration with existing systems, and enables you to enhance agent capabilities over time.

Well-designed protocols also establish consistent security patterns for authentication and authorization across your agent ecosystem. Most importantly, protocol portability preserves your freedom to adopt new agent frameworks and capabilities as they emerge. Choosing open protocols protects your investment in agent development while maintaining interoperability with third-party systems.

## Advantages of open protocols


When implementing your own extensions or building custom agent systems, open protocols offer compelling advantages:
+ **Documentation and transparency** – Typically provide comprehensive documentation and transparent implementations
+ **Community support** – Access to broader developer communities for troubleshooting and best practices
+ **Interoperability guarantees** – Better assurance that your extensions will work across different implementations
+ **Future compatibility** – Reduced risk of breaking changes or deprecation
+ **Influence on development** – Opportunity to contribute to protocol evolution

# Agent-to-agent protocols


The following table provides an overview of agentic protocols that enable multiple agents to collaborate, delegate tasks, and share information.


| 
| 
| **Protocol** | **Ideal for** | **Considerations** | 
| --- |--- |--- |
| [MCP inter-agent communication](https://aws.amazon.com/blogs/opensource/open-protocols-for-agent-interoperability-part-1-inter-agent-communication-on-mcp/) | Organizations seeking flexible agent collaboration patterns |   An extension to the Model Context Protocol (MCP) proposed by AWS that builds on its existing foundation for agent-to-agent communication   Enables seamless agent collaboration with OAuth-based security   | 
| [A2A protocol](https://github.com/a2aproject/A2A) | Cross-platform agent ecosystems |   Backed by Google   Newer standard with more limited adoption compared to MCP   | 

## Deciding among protocol options


When implementing agent-to-agent communication, match your specific communication requirements with the appropriate protocol capabilities. Different interaction patterns require different protocol features. The following table outlines common communication patterns and recommends the most suitable protocol choices for each scenario.


| 
| 
| **Pattern** | **Description** | **Ideal protocol choice** | 
| --- |--- |--- |
| Simple request and response | One-off interactions between agents | MCP with stateless flows | 
| Stateful dialogues | Ongoing conversations with context | MCP with session management | 
| Multi-agent collaboration | Complex interactions between multiple agents | MCP inter-agent or AutoGen | 
| Team-based workflows | Hierarchical agent teams with defined roles | MCP inter-agent, CrewAI, or AutoGen | 

Beyond communication patterns, several technical and organizational factors can influence your protocol selection. The following table outlines key considerations that can help you evaluate which protocol aligns most closely with your specific implementation requirements.


| 
| 
| **Consideration** | **Description** | **Example** | 
| --- |--- |--- |
| Security model | Authentication and authorization requirements | OAuth 2.0 in MCP | 
| Deployment environment | Where agents will run and communicate | Distributed or single machine | 
| Ecosystem compatibility | Integration with existing agent frameworks | LangChain or Strands Agents | 
| Scalability needs | Expected growth in agent interactions | Streaming capabilities of MCP | 

# Selecting agentic protocols


For most organizations building production agent systems, the Model Context Protocol (MCP) offers the most comprehensive and well-supported foundation for agent-to-agent communication. MCP benefits from active development contributions from AWS and the open-source community. 

Selecting the right agentic protocols is important for organizations looking to implement agentic AI effectively. Considerations differ based on organizational context.

## Agentic protocol selection considerations


Organizations should consider the following best practices when selecting protocols for agentic AI systems::
+ **Prioritize open standards** – Organizations should adopt open protocols such as the MCP to help ensure long-term interoperability, extensibility, and to reduce the risk of vendor lock-in. 
+ **Balance speed and flexibility** – Startups and early adopters may begin with well-supported proprietary protocols for rapid development but should define a migration path to open standards as systems mature.
+ **Implement abstraction layers** – Enterprises should implement protocol abstraction to simplify migration, enable hybrid adoption, and future-proof integration strategies.
+ **Emphasize security and compliance** – Organizations in regulated industries should select protocols with robust authentication, encryption, and audit capabilities to meet governance and compliance requirements. 
+ **Evaluate ecosystem maturity** – All organizations should assess the health, adoption, and community support of each protocol to ensure sustainability and minimize technical debt. 
+ **Engage in standards development** – Organizations should participate in standards bodies or open-source communities to help shape protocol evolution and influence best practices.
+ **Account for data sovereignty** – Government and regulated sectors should ensure protocol choices align with data residency and sovereignty requirements across deployment regions.
+ **Leverage managed services** – Where possible, use managed or serverless implementations of agentic protocols to reduce operational complexity and accelerate deployment.

# Implementation strategy for agentic protocols


To effectively implement agentic protocols across your organization, consider the following strategic steps:

1. **Start with standards alignment** – Adopt established open protocols where possible.

1. **Create abstraction layers** – Implement adapters between your systems and specific protocols.

1. **Contribute to open standards** – Participate in protocol development communities.

1. **Monitor protocol evolution** –Stay informed about emerging standards and updates.

1. **Test interoperability regularly** – Verify that your implementations remain compatible.

# Getting started with MCP


AWS actively supports the Model Context Protocol (MCP) through contributions to the protocol’s development and implementation. AWS is collaborating with leading open-source agent frameworks, including LangGraph, CrewAI, and LlamaIndex, to shape the future of inter-agent communication on the protocol.

To implement the MCP in your agent architecture, take the following actions:

1. Explore MCP implementations in frameworks like the [Strands Agents SDK](https://strandsagents.com/).

1. Review the [Model Context Protocol](https://modelcontextprotocol.io/introduction) technical documentation.

1. Read [Open Protocols for Agent Interoperability Part 1: Inter-Agent Communication on MCP](https://aws.amazon.com/blogs/opensource/open-protocols-for-agent-interoperability-part-1-inter-agent-communication-on-mcp/) (AWS Blog) to learn about agent interoperability.

1. Join the [MCP community](https://github.com/orgs/modelcontextprotocol/discussions) to influence the protocol's evolution.

MCP provides a communication layer that enables agents to interact with external data and services and can also be used to enable agents to interact with other agents. The protocol's [Streamable HTTP transport](https://modelcontextprotocol.io/docs/concepts/transports#streamable-http) implementation gives developers a comprehensive set of interaction patterns without having to reinvent the wheel. These patterns support both stateless request/response flows and stateful session management with persistent IDs.

By adopting open protocols like MCP, you position your organization to build agent systems that remain flexible, interoperable, and adaptable as AI technology evolves. For information about agent-to-tool protocol implementation, see [Tool integration strategy](tool-integration-strategy.md) later in this guide.

# Getting started with A2A


The Agent2Agent (A2A) protocol enables decentralized collaboration between agents through a shared semantic layer. Instead of routing all work through a central orchestrator, A2A allows agents to discover each other, advertise their capabilities, negotiate tasks, and share context using a lightweight JSON-based protocol. Each agent publishes a capability manifest.

The following example shows a simplified A2A capability manifest that advertises an agent’s supported actions, required inputs, and operational metadata to enable discovery and task negotiation:

```
{
  "can": ["summarize.text", "extract.keywords"],
  "needs": ["document.input"],
  "meta": { "version": "1.0.3", "latencyMs": 120 }
}
```

This model enables dynamic capability matching, mid-task delegation, and cross-organizational collaboration. Agents can self-organize around tasks, form temporary working groups, and adapt as new capabilities enter or exit the system.

A2A supports interactions ranging from simple stateless requests to multi-step negotiation sessions, including:
+ Direct peer-to-peer messaging for low-latency collaboration
+ Semantic task negotiation, where agents select the most suitable peer
+ Capability-based discovery, enabling emergent division of labor
+ Session anchoring for stateful multi-step interactions

By adopting open, agent-native protocols like A2A, organizations create AI systems that are modular, interoperable, and capable of cross-boundary collaboration. A2A ensures that agent ecosystems remain flexible and can evolve as new agents, teams, or external systems are introduced, without requiring rigid orchestration layers or prior coupling.

To implement the A2A protocol in your agent architecture, take the following actions: 

1. **Review the A2A Protocol Specification** – Read the latest version of the [Agent2Agent (A2A) Protocol Specification](https://a2a-protocol.org/latest/specification/) to learn how capability manifests, negotiation flows, and the agent handshake operate.

1. **Explore A2A-compatible runtimes** – Evaluate frameworks such as the Strands Agents SDK or custom runtime layers that support A2A-style capability manifests and peer-to-peer negotiation.

1. **Implement a capability manifest for your agents** – Define each agent’s `can`, `needs`, and `meta` fields to enable discovery, matchmaking, and intent-level collaboration.

1. **Experiment with A2A negotiation patterns** – Use the request–offer–accept loop, structured capability queries, or gossip-based discovery to understand how agents reason about who should handle a task.

1. **Test A2A in a mixed infrastructure environment** – Combine A2A peer negotiation with event routing that’s native to AWS through Amazon EventBridge to evaluate hybrid coordination patterns.

1. **Join the A2A community** – Engage with the [open working group](https://a2a-protocol.org/latest/community/) to stay up to date with extensions, security recommendations, and cross-vendor interoperability improvements, and [contribute to the development](https://github.com/a2aproject/A2A?tab=contributing-ov-file) of the protocol.