Agent2Agent (A2A) Protocol Explained: The Complete Guide to Cross-Platform Agent Collaboration

Introduction

By 2026, a single enterprise workflow may span multiple AI agents built by different teams, on different frameworks, and hosted on different platforms. A planning agent built with OpenAI's SDK, a research agent built with Claude, an internal SQL agent powered by Llama, and a third-party CRM agent owned by another company—each operating in isolation[reference:0]. Without a shared protocol, every pair of agents needs a custom integration, every handoff is a bespoke API contract, and every authentication boundary is a security surface to harden manually[reference:1]. The Agent2Agent (A2A) Protocol was created to solve this fundamental challenge. Launched by Google and over 50 technology partners in April 2025, and now hosted by the Linux Foundation, A2A is an open standard that enables AI agents to discover, communicate, and collaborate with each other regardless of their underlying framework, vendor, or programming language[reference:2][reference:3]. This article provides a comprehensive guide to the A2A protocol, covering its design principles, core concepts, architecture, security model, and its complementary relationship with the Model Context Protocol (MCP).

What Is the Agent2Agent (A2A) Protocol?

Definition and Purpose

The Agent2Agent (A2A) Protocol is an open standard that defines how independent AI agents discover each other, delegate tasks, and exchange data securely across different platforms[reference:4]. Where a REST API returns raw data and MCP provides controlled access to tools and data sources, A2A is built for agent-to-agent delegation: one agent needs to hand off a task to another agent that independently manages its own reasoning, tools, and responses[reference:5]. Think of A2A as a common language or universal translator for agent ecosystems[reference:6].

The protocol reached v1.0 in 2026, marking the first stable, production-ready version of the open standard[reference:7]. It is governed under the Linux Foundation (which has hosted the project since June 2025) and is supported by a technical steering committee with representatives from AWS, Cisco, Google, IBM Research, Microsoft, Salesforce, SAP, and ServiceNow[reference:8][reference:9].

Design Principles

While designing the protocol with its partners, the A2A community adhered to several key principles[reference:10]:

• Embrace agentic capabilities: A2A focuses on enabling agents to collaborate in their natural, unstructured modalities, even when they don't share memory, tools, and context.
• Build on existing standards: A2A is built on top of existing, popular standards including HTTP, JSON-RPC, and Server-Sent Events (SSE)[reference:11].
• Async-first by default: The protocol promotes an asynchronous-first approach for long-running tasks and streaming responses for incremental updates.
• Secure by design: A2A mandates secure transport with HTTPS, authentication, and authorization.
• Extensible: The protocol supports formal extensions and custom bindings, governed by a tiered promotion process so the core stays stable.

Core A2A Concepts

Agent Cards: Discovery and Capability Description

Agent Cards are the foundation of A2A's discovery mechanism[reference:12]. An Agent Card is a JSON discovery document published at a well-known URL path—typically /.well-known/agent.json relative to the agent's endpoint[reference:13]. The Agent Card describes the agent's name and purpose, its capabilities and specific skills, the HTTP URL endpoint for agent communication, transport and security schemes, and authentication requirements[reference:14].

When an orchestrator connects to an A2A-enabled agent, it automatically retrieves the Agent Card to discover the agent's identity and capabilities[reference:15]. This discovery pattern—fetching the Agent Card before communication begins—is the essential first step in any A2A interaction. For enterprise deployments, v1.0 introduces Signed Agent Cards, providing cryptographic verification of agent identity and metadata before interaction across organizational boundaries[reference:16].

Tasks: The Unit of Work

A Task is the unit of work in A2A[reference:17]. When an orchestrator delegates to an A2A agent, it sends a task containing the user request and associated context. The external agent processes the task independently using its own tools and reasoning, and returns a structured response. Tasks support both synchronous and asynchronous execution modes. If a task is simple and can be completed immediately, the agent executes it and responds synchronously. If the task requires more time, the agent responds with an acknowledgment and streams progress or status updates back to the client using Server-Sent Events (SSE) or webhooks for push notifications[reference:18][reference:19].

Context ID: Session Continuity

The Context ID maintains session continuity across agent boundaries. When a user's session spans multiple turns, the Context ID associates each delegated task with the same ongoing conversation. This allows the A2A agent to reference earlier turns in the session when forming its response, supporting more natural multi-turn interactions than stateless API calls permit.

A2A vs. MCP: Complementary, Not Competing

A common point of confusion is the relationship between A2A and the Model Context Protocol (MCP). The two protocols are not competitors—they are complementary, solving two different problems at different layers of the stack[reference:20][reference:21].

Dimension	Model Context Protocol (MCP)	Agent2Agent (A2A)
Primary Purpose	Agent-to-tool communication[reference:22]	Agent-to-agent communication[reference:23]
What It Standardizes	How an agent connects to its tools, APIs, and resources[reference:24]	How independent agents discover each other, delegate tasks, and share results[reference:25]
Interaction Model	Client-to-tool. Local subprocess via stdio, or remote via Streamable HTTP[reference:26]	Client-server over HTTP(S) with fluid roles. Any agent can act as client or server[reference:27]
Primary Use Case	Giving an LLM access to a database, file system, search engine, or specialized function[reference:28]	Multi-agent orchestration and workflow handoffs across teams or vendors[reference:29]
Best Used For	Controlled tool and data access[reference:30]	Cross-platform agent delegation and collaboration[reference:31]

MCP serves as a standardization layer for AI applications to communicate effectively with external services, such as APIs, data sources, and predefined functions[reference:32]. Meanwhile, A2A focuses on agent collaboration, facilitating communication between AI agents[reference:33].

In production enterprise systems, agents frequently implement both protocols at once. A scalable compound AI application relies on A2A for high-level orchestration and MCP for concrete tool execution[reference:34]. By leveraging both A2A for inter-agent collaboration and MCP for tool integration, developers can build more powerful, flexible, and interoperable AI systems. To put it simply: Use MCP when an agent must interface with a tool, database, or service that expects a fixed input/output format. Use A2A when agents need to negotiate, collaborate, or share varied types of information[reference:35].

Enabling Technologies for Cross-Platform Collaboration

Agent Development Kit (ADK) and RemoteA2aAgent

Google's Agent Development Kit (ADK) provides a powerful abstraction for cross-platform agent collaboration. ADK's RemoteA2aAgent abstraction turns any remote A2A-compliant service into a local sub-agent with a few lines of code[reference:36]. This enables cross-language agent collaboration so teams can build agents in the best language for the job without rewriting code[reference:37]. A Python agent can seamlessly collaborate with a Go agent, a Java agent, or an agent built in any other language, as long as both expose A2A-compliant interfaces[reference:38].

Cross-Framework Interoperability

A2A enables true cross-framework interoperability. Agents built with LangGraph, CrewAI, Semantic Kernel, or any A2A-compliant platform can call each other as sub-agents[reference:39]. The protocol has been integrated with major frameworks including OpenAI Agents SDK, LangGraph, and CrewAI, enabling developers to build specialized agents using their preferred framework and expose them as A2A-compliant services[reference:40]. This means you can discover and call remote A2A agents from any vendor, and expose your own agents so that any A2A-compliant client can reach them[reference:41].

Multi-Protocol Bindings and Version Negotiation

A2A v1.0 supports multiple protocol bindings including JSON+HTTP, gRPC, and JSON-RPC[reference:42]. The protocol also features seamless version negotiation, ensuring agents built with different versions can interoperate with predictable behavior[reference:43]. This heterogeneous environment support enables interoperability across diverse technology stacks, so enterprises are not tied to a single vendor or platform[reference:44].

Architecture and Workflow

Client Agent and Remote (Server) Agent

A2A defines two primary roles in agent communication[reference:45]:

• Client Agent: Responsible for creating requests and handling end-user interaction. The client agent initiates communication by discovering remote agents and sending messages.
• Remote (Server) Agent: Responsible for taking action on these requests. The server agent exposes endpoints for discovery and message handling.

Any agent can act as a client agent or a remote agent at any time, depending on the context. This flexibility enables complex, multi-directional communication patterns[reference:46].

Workflow: Discovery → Initiation → Completion

A2A communication follows a three-step pattern[reference:47]:

Step 1: Discovery The client agent retrieves the remote agent's Agent Card from /.well-known/agent.json to discover its capabilities, skills, and communication endpoint[reference:48].

Step 2: Initiation The client agent authenticates according to the card's requirements and sends a task to the remote agent via the A2A invocation API. The task contains the user request and associated context[reference:49].

Step 3: Completion The remote agent processes the task and returns a response. For simple tasks, this is synchronous. For long-running tasks, the agent streams progress updates or uses webhooks for push notifications[reference:50].

Security Model

Authentication and Authorization

From an authentication and authorization point of view, A2A treats agents as standard enterprise applications[reference:51]. The primary identity of agents is managed at the HTTP transport layer, not within payloads of exchanged messages. Credentials are included by client agents in the appropriate HTTP header of each request to the remote agent[reference:52]. Each remote agent may have different authentication requirements, which client agents discover from the remote agent's Agent Card. The protocol supports OAuth2 and OpenID Connect for authentication, and v1.0 adds enhanced security scheme declarations with mutual TLS support and modern OAuth 2.0 flows[reference:53].

Signed Agent Cards and Multi-Tenancy

A2A v1.0 introduces Signed Agent Cards, providing cryptographic verification of agent identity and metadata. This establishes trust before interaction across organizational boundaries[reference:54]. The release also adds multi-tenancy support, allowing a single endpoint to securely host many agents[reference:55].

Opaque Agents and Secure Boundaries

A critical architectural advantage of A2A is the Secure Boundary—the ability for agents to communicate without exposing their "secret sauce." In enterprise scenarios, agents need to leverage sensitive data or bespoke internal processes that cannot be exposed to a public LLM or a third-party system. A2A enables agent-to-agent delegation where the external agent remains opaque: your orchestrator delegates a task, and the A2A agent decides how to handle it using its own tools, its own reasoning, and its own logic.

Best Practices for Cross-Platform Agent Collaboration

Microsoft's multi-agent guidance outlines several key best practices[reference:56][reference:57]:

• Prefer platform-native orchestration for internal flows where possible, and use MCP for secure, authenticated access to tools and data[reference:58].
• Use A2A for cross-platform agent-to-agent messaging. Design for capability discovery and task contracts. Require agents to publish "agent cards" (capabilities) and use A2A's task and artifact model so workflows can discover, invoke, and track long-running tasks across runtimes[reference:59].
• Standardize security and management of connected agents by using published SDKs with native MCP and A2A support[reference:60].
• Implement least privilege when calling tools and accessing data[reference:61].
• Include users in the workflow and communicate when agents collaborate. Require human approvals for high-impact cross-agent actions[reference:62].
• Reconcile conflicting outputs from different agents[reference:63].
• Design for parallelism, limit inter-agent context to what is strictly necessary, and use short-term memory to avoid redundant work[reference:64].

Real-World Applications

Cross-Language Agent Teams

Organizations are already building cross-language agent teams using A2A. A contract compliance pipeline might have a Python agent that extracts contract terms using Gemini and a Go agent that validates them against corporate policy. The two services are connected by the A2A protocol and orchestrated by ADK[reference:65]. This enables teams to build agents in the best language for the job without rewriting code[reference:66].

Enterprise Platform Integration

Major enterprise platforms now support A2A natively. Oracle Fusion Cloud Applications published AI agents can collaborate with AI agents in other platforms using the A2A protocol[reference:67]. ServiceNow AI Agents can now take part in broader, cross-platform workflows that Neuro AI coordinates automatically[reference:68]. Salesforce and Google Cloud have partnered to enable AI agents to execute end-to-end workflows across both platforms[reference:69].

Supply Chain and Business Process Automation

Businesses are building powerful A2A systems for supply chain and business process automation[reference:70]. A planner agent delegates inventory queries to an internal warehouse agent and shipping queries to a third-party logistics agent over A2A[reference:71]. A2A workflows are generally best for routine, well-defined tasks where boundaries can be set in advance and the stakes per transaction are bounded[reference:72].

Observability and Governance

In production environments where a request might cross multiple A2A hops, end-to-end observability stops being optional[reference:73]. FutureAGI's approach instruments A2A at the protocol layer so every cross-agent handoff is a queryable OpenTelemetry span[reference:74]. Capability lookups, task creation, message exchanges, and lifecycle transitions all emit spans with agent trajectory step, the calling and called agent IDs, and the task ID[reference:75].

This stitching is the unlock: a team running a multi-agent workflow where Agent A delegates a sub-task to Agent B can now answer "did Agent B finish the sub-task correctly?" from inside Agent A's trace view[reference:76]. This enables teams to build dashboards showing per-counterparty task completion, p99 latency, and cost attribution[reference:77].

Future Outlook

Protocol Evolution

The A2A protocol continues to evolve. Version 1.0 introduced a more stable interface, signed Agent Cards, multi-tenancy support, and improved security posture[reference:78][reference:79]. The protocol's extension framework allows for continued evolution while keeping the core stable. The community is actively working on enhancements including ledger-anchored identities and micropayments for AI agents, pointing toward a future where agents not only collaborate but also transact in decentralized agent economies.

Multi-Agent Economies

As A2A adoption grows, the protocol is becoming the foundation for multi-agent economies. The first production consequences are already visible: a platform team that exposes its support agent over A2A can be invoked by any A2A-compliant orchestrator without writing client code. A security team gains a single boundary. A product lead can compose workflows that mix internal and third-party agents without negotiating per-pair integration contracts[reference:80].

Conclusion

The Agent2Agent (A2A) Protocol represents a fundamental shift in how AI agents interact. By providing a standardized, vendor-neutral language for agent-to-agent communication, A2A breaks down the silos that have prevented agents from collaborating across frameworks, vendors, and organizational boundaries. Its design principles—embracing agentic capabilities, building on existing standards, async-first by default, secure by design, and extensible—provide a solid foundation for the future of multi-agent systems. Together with complementary standards like MCP for tool integration, A2A enables developers to build powerful, flexible, and interoperable AI systems where agents can discover each other, delegate tasks, and share results—ushering in a new era of collaborative artificial intelligence[reference:81].

Related Concepts

• Multi-Agent Systems
• Model Context Protocol (MCP) Explained
• AI Agent Architecture
• Agent Orchestration and Coordination
• Agent Discovery and Capability Description
• JSON-RPC and HTTP-Based Protocols
• Agent Security and Opaque Boundaries
• Cross-Framework Agent Interoperability
• Agent Development Kit (ADK)
• Enterprise AI Agent Deployments

References

1. Google Cloud. Build Cross-Language Multi-Agent Team with Google's Agent Development Kit and A2A. Google Developers Blog. June 2026.
2. Oracle. Collaborate with AI Agents in other platforms using the Agent2Agent (A2A) Protocol. Oracle Fusion Cloud Documentation. 2026.
3. Tyk. A2A protocol: Architecture and technical specification. Tyk Learning Center. 2026.
4. FutureAGI. What Is the Agent2Agent (A2A) Protocol?. FutureAGI. 2026.
5. Beam. Agent2Agent vs MCP: The 2 Protocols Your 2026 AI Agent Stack Actually Runs On. Beam. 2026.
6. Linux Foundation. A2A Protocol Surpasses 150 Organizations, Lands in Major Cloud Platforms, and Sees Enterprise Production Use in First Year. Linux Foundation. April 2026.
7. A2A Protocol. A2A Protocol Ships v1.0: Production-Ready Standard for Agent-to-Agent Communication. a2a-protocol.org. 2026.
8. Microsoft. Multi-agent patterns. Microsoft Learn. 2026.
9. AWS. Introducing agent-to-agent protocol support in Amazon Bedrock AgentCore Runtime. AWS. November 2025.
10. Krishnan, N. Beyond Context Sharing: A Unified Agent Communication Protocol (ACP) for Secure, Federated, and Autonomous Agent-to-Agent (A2A) Orchestration. arXiv:2602.15055. February 2026.