What Is Google's A2A Protocol? The New Standard for AI Agent Communication

If you've been paying attention to the AI engineering space, you've probably heard about MCP - Anthropic's Model Context Protocol that lets AI agents connect to tools and data sources. But there's another protocol that's just as important, and it solves a completely different problem.

Google's Agent2Agent (A2A) protocol is an open standard that lets AI agents communicate with each other. Not with tools. Not with databases. With other agents.

And if you're building your career in software engineering, understanding agent interoperability protocols is quickly becoming a must-have skill.

Why A2A Exists

Here's the problem. Every major company is building AI agents. Salesforce has its agents. SAP has agents. ServiceNow, Atlassian, Intuit - they all have agents. Your company probably has agents too, or will soon.

But these agents are built on different frameworks, by different teams, running on different infrastructure. They can't talk to each other. It's like the early internet before HTTP - everyone had computers, but they couldn't communicate.

Google launched A2A in April 2025 to fix this. The protocol provides a standard way for agents to discover each other, exchange information, and coordinate on tasks - regardless of who built them or what framework they use.

This isn't just a Google thing either. More than 100 companies now support A2A, including Amazon, Cisco, Microsoft, Salesforce, SAP, PayPal, Atlassian, and many others. In June 2025, Google donated A2A to the Linux Foundation to ensure neutral, vendor-agnostic governance. Amazon and Cisco joined Google as founding members of the Agent2Agent Foundation. The Agent Communication Protocol (ACP) has also merged into A2A under the Linux Foundation umbrella.

This is becoming an industry standard, not a proprietary tool.

How A2A Works - The Technical Details

A2A follows a client-server architecture. One agent (the client) sends tasks to another agent (the server). All communication happens over HTTP(S) using JSON-RPC 2.0, with an optional gRPC binding for higher-performance deployments added in version 0.3.

There are four core concepts you need to understand.

1. Agent Cards

Before agents can collaborate, they need to discover each other's capabilities. Agent Cards solve this. An Agent Card is a JSON metadata document that an A2A server publishes, describing:

• Identity - the agent's name and description
• Service endpoint - where to reach it
• Skills - what it can do (e.g., "search job candidates," "run background checks")
• Supported input/output modes - text, files, structured data
• Authentication requirements - how to connect securely
• Capabilities - whether it supports streaming, push notifications, etc.

Think of Agent Cards like an API's OpenAPI spec, but for AI agents. A client agent reads the card and knows exactly what the server agent can do and how to interact with it.

2. Tasks

A Task is the fundamental unit of work in A2A. When a client agent wants something done, it creates a task and sends it to the server agent.

Tasks are stateful. They progress through a defined lifecycle:

• submitted - the task has been received
• working - the agent is actively processing it
• input-required - the agent needs more information from the client
• completed - the work is done
• failed - something went wrong
• canceled - the task was canceled
• auth-required - authentication is needed before proceeding

This state machine is important. It means agents can handle long-running, multi-step work - not just simple request-response interactions. A task that takes hours or even days can report its progress, ask for clarification, and eventually deliver results.

3. Messages and Artifacts

Messages are the units of communication between client and server during a task. They carry context, instructions, and responses back and forth.

Artifacts are the outputs - the deliverables that a task produces. When a server agent completes work, it returns artifacts that might include text, files, structured data, or other content types.

4. Streaming and Push Notifications

A2A supports real-time streaming via Server-Sent Events (SSE) for HTTP or server streaming RPCs for gRPC. This lets clients watch tasks progress in real time.

For very long-running tasks - think minutes, hours, or days - A2A supports push notifications. The server agent can send webhook callbacks to the client when something significant happens, so the client doesn't need to maintain a persistent connection. This is particularly useful for mobile clients or serverless architectures.

A2A vs MCP - They're Not Competitors

This is the question everyone asks, and the answer is simple: A2A and MCP solve different problems and work together.

MCP (Model Context Protocol) handles vertical integration - connecting an agent to tools, APIs, and data sources. It's how an agent reads a database, calls an API, or accesses a file system. MCP is agent-to-tool communication.

A2A (Agent2Agent Protocol) handles horizontal integration - connecting agents to other agents. It's how a hiring agent collaborates with a background-check agent, or how a procurement agent coordinates with a supplier's inventory agent. A2A is agent-to-agent communication.

In practice, they layer together. Imagine this scenario:

1. You ask your company's hiring agent to find candidates for a role
2. The hiring agent uses A2A to contact a recruiting platform's sourcing agent
3. That sourcing agent uses MCP to query its internal candidate database, pull resume files, and call a skills-assessment API
4. The sourcing agent sends results back via A2A to your hiring agent
5. Your hiring agent uses A2A to contact a scheduling agent to set up interviews
6. The scheduling agent uses MCP to access calendar APIs and send meeting invites

MCP gives agents their capabilities. A2A lets agents combine those capabilities across organizational boundaries. You need both.

It's worth noting that both protocols have found a home at the Linux Foundation - A2A under the Agent2Agent Foundation, and MCP under the Agentic AI Foundation. The industry is clearly converging on these as complementary standards.

Real-World Use Cases

A2A isn't theoretical. Here's where it's being applied.

Enterprise Hiring

A hiring manager's agent coordinates with specialized remote agents to source candidates, schedule interviews, run background checks, and manage offer letters. Each of these might be a different vendor's agent, but A2A lets them collaborate seamlessly.

Supply Chain and Procurement

Procurement agents collaborate with approval agents, logistics agents, and warehouse agents to automate the chain from order generation to delivery. Forecasting agents work with inventory management agents to automatically adjust stock levels based on sales data and market trends.

Financial Services

Anti-fraud agents collaborate with credit assessment agents to evaluate risk in real-time during transaction processing. Market analysis agents work with investment strategy agents to integrate data across different markets. Compliance agents coordinate with risk management agents to keep up with evolving regulatory requirements.

IT Operations

Performance monitoring agents collaborate with resource management agents to automatically adjust infrastructure based on load conditions. Incident response agents coordinate with diagnostic agents and remediation agents to resolve issues faster.

Commerce

PayPal is supporting A2A for next-generation commerce experiences. Imagine a shopping agent that negotiates with a merchant's pricing agent, coordinates with a shipping agent, and works with a payment agent - all through standardized A2A communication.

What This Means for Your Career

If you're a software engineer - whether you're preparing for interviews or building your career - agent interoperability is a skill set worth investing in now. Here's why.

It's Becoming Core Infrastructure

Agent protocols are following the same trajectory as REST APIs and GraphQL. They started as niche topics, became interview questions, and are now fundamental knowledge for backend and full-stack engineers. A2A and MCP are on that same path.

The Job Market Is Shifting

Companies building multi-agent systems need engineers who understand these protocols. "Experience with A2A/MCP" is already showing up in job descriptions, and that trend will accelerate. Being early to this gives you a real advantage.

System Design Interviews Will Include This

If you're preparing for senior or staff-level interviews, expect system design questions involving multi-agent architectures. Understanding how agents discover each other (Agent Cards), coordinate work (Tasks), and handle failures (lifecycle states) gives you the vocabulary and mental models to answer these well.

It's Not Just AI Companies

The 100+ companies backing A2A include banks, retailers, consulting firms, and enterprise software vendors. This isn't limited to AI-first startups. Traditional enterprises are building agent systems, and they need engineers who can wire them together.

Building Projects With A2A Sets You Apart

Side projects that demonstrate agent interoperability are impressive. Building two agents that discover and collaborate with each other via A2A shows you understand distributed systems, protocol design, and the agentic AI stack - all in one project.

How to Get Started

If you want to learn A2A hands-on, here's a practical path.

Read the spec. The official documentation is at a2a-protocol.org. Start with the overview and work through the specification. It's well-written and approachable.

Pick an SDK. There are official SDKs for both Python (a2a-python on GitHub) and JavaScript/TypeScript. The Python SDK implements the v0.3 specification and has good documentation.

Follow the codelab. Google has a hands-on codelab that walks you through building a purchasing concierge agent and a remote seller agent that communicate via A2A on Cloud Run. It's available on Google Codelabs.

Build something. The best way to learn is to build. Create two simple agents - maybe one that generates reports and one that summarizes them - and wire them together with A2A. Focus on implementing Agent Cards, task lifecycle management, and handling the input-required state where agents need to negotiate.

Explore with Google's ADK. Google's Agent Development Kit (ADK) has built-in A2A support, making it straightforward to build agents that speak the protocol natively.

Dive into the GitHub repo. The a2aproject/A2A repository contains the specification, sample implementations, and community contributions. It's a good resource for seeing how others are building with A2A.

The Big Picture

We're in the early stages of a shift where AI agents move from isolated tools to collaborative systems. A2A is the protocol making that collaboration possible across organizational and vendor boundaries.

The analogy isn't perfect, but think about what HTTP did for the web. Before HTTP, computers could do useful things individually. HTTP gave them a standard way to communicate, and everything changed. A2A is trying to do the same thing for AI agents.

Whether you're preparing for interviews, building products, or planning your career trajectory, understanding A2A and the broader agent interoperability landscape is time well spent. The engineers who understand how to build, connect, and orchestrate multi-agent systems will be in high demand.

The protocol is open source, the SDKs are free, and the ecosystem is growing fast. There's no barrier to getting started - just the decision to do it.