Agent-to-Agent (A2A) Protocol Explained

The Interoperability Problem

Before A2A, multi-agent systems were closed ecosystems. Agents built with LangGraph could only collaborate with other LangGraph agents. Agents built with CrewAI could only work with other CrewAI agents. If you wanted a research agent from one framework to collaborate with a writing agent from another framework, you had to build custom integration code for each framework pair, a process that was expensive, fragile, and did not scale as the number of frameworks grew.

The interoperability problem becomes more acute in enterprise settings where different departments may have adopted different AI platforms. The marketing team might use CrewAI for content workflows. The engineering team might use LangGraph for code analysis. The customer service team might use a custom framework. Without a common protocol, these department-level agent systems cannot collaborate, creating the same organizational silos that the agents were supposed to help eliminate.

A2A solves this problem by defining a standard interface that any agent can implement regardless of its underlying framework. An agent that speaks A2A can discover other A2A-speaking agents, understand their capabilities, send them tasks, receive results, and coordinate complex workflows, all without knowing anything about the other agent's internal implementation. This interoperability enables multi-agent systems that span frameworks, vendors, and organizational boundaries.

Agent Cards

Agent cards are the discovery mechanism in A2A. Every A2A-compatible agent publishes an agent card, a JSON document that describes the agent's identity, capabilities, supported interaction modes, and endpoint URL. Agent cards are hosted at a well-known URL path, making them discoverable through simple HTTP requests without requiring a centralized registry.

An agent card contains the agent's name and description (what it does and what expertise it offers), its supported skills (specific task types it can handle), its interaction modes (synchronous request-response, asynchronous with callbacks, or streaming), its authentication requirements, and the URL where it accepts task requests. Client agents and orchestrators use this information to decide which remote agents to engage for specific tasks and how to communicate with them.

The agent card model is deliberately similar to how web services publish API documentation. This familiarity makes A2A accessible to developers who are already experienced with building and consuming web APIs. The key difference is that agent cards describe capabilities in natural language rather than in formal API schemas, because AI agents understand and route based on natural language descriptions of what other agents can do rather than on formal type definitions.

Task Lifecycle

A2A defines a structured task lifecycle that governs how work flows between agents. A client agent creates a task by sending a task creation request to a remote agent's endpoint. The remote agent acknowledges the task and begins processing it. The client can check the task's status at any time through polling or receive status updates through push notifications. When the remote agent completes the task, the client retrieves the result.

Tasks move through defined states: submitted (the task has been received but not yet started), working (the agent is actively processing the task), input-required (the agent needs additional information from the client before it can continue), completed (the task is finished and results are available), and failed (the task could not be completed). These state transitions are clearly defined so that client agents can implement appropriate handling logic for each state without needing to understand the remote agent's internal processing details.

The input-required state is particularly important for multi-agent workflows because it enables iterative collaboration between agents. A research agent might submit a task to a data analysis agent, which discovers that it needs clarification about the analysis parameters. The data analysis agent transitions to the input-required state, the research agent provides the needed information, and the data analysis agent continues processing. This back-and-forth collaboration happens through standard A2A messages without custom integration code.

Message Format and Artifacts

A2A messages use a structured format that includes both human-readable text and machine-readable data. Each message can contain one or more parts, where each part has a content type and a body. Text parts contain natural language messages. Data parts contain structured JSON data. File parts contain references to binary files. This multipart format allows agents to exchange rich information, combining natural language explanations with structured data and file attachments in a single message.

Artifacts are the outputs produced by agents during task processing. An artifact might be a generated document, a data analysis result, a code file, or any other tangible output. Artifacts are distinct from messages because they represent the deliverable work product of the task rather than communication between agents. The artifact model provides a clean separation between the conversation (messages) and the results (artifacts), making it easy for client agents to extract and use the results without parsing conversation history.

A2A and MCP: Complementary Protocols

A2A is often discussed alongside the Model Context Protocol (MCP), developed by Anthropic. While both protocols address interoperability in AI systems, they serve different purposes and operate at different levels. MCP standardizes how agents connect to tools and data sources, defining a common interface for capabilities like database queries, API calls, file operations, and web browsing. A2A standardizes how agents communicate with each other, defining how one agent discovers, delegates to, and receives results from another agent.

The two protocols are complementary rather than competitive. An agent might use MCP to connect to its tools (databases, APIs, file systems) and A2A to collaborate with other agents. A multi-agent system might have each individual agent using MCP for its tool integrations while the agents communicate with each other through A2A. Together, MCP and A2A provide a complete interoperability stack: MCP for vertical integration (agent to tools) and A2A for horizontal integration (agent to agent).

This complementary relationship means that adopting one protocol does not preclude adopting the other. Organizations can implement MCP for tool standardization today and add A2A for agent interoperability later, or vice versa. The protocols are designed to work together, and agents that implement both protocols gain the benefits of standardized tool access and standardized agent collaboration simultaneously.

Adoption and Industry Impact

A2A was announced by Google in April 2025 with support from over 50 technology partners, including Salesforce, SAP, MongoDB, Atlassian, and major cloud providers. The broad initial support suggests strong industry appetite for agent interoperability standards. The protocol is open source and designed to be framework-agnostic, meaning any agent system can implement A2A support regardless of its underlying technology stack.

For enterprises, A2A's most significant implication is that it reduces vendor lock-in for AI agent investments. An organization can build agents using whichever framework best suits each use case, confident that those agents can interoperate through A2A. This freedom to choose the best tool for each job, rather than standardizing on a single framework for interoperability reasons, is expected to accelerate enterprise adoption of multi-agent systems.

The protocol is still maturing as of 2026, with implementations varying in completeness across frameworks. Early adopters should expect to encounter gaps in tooling, documentation, and framework support. However, the fundamentals of the protocol are stable, and building A2A-compatible agents today positions organizations well for the increasingly interoperable agent ecosystem that is emerging.