Author(s): Divy Yadav

Originally published on Towards AI.

You want to order a burger under $15. You open Zomato.

Here’s what should happen: One request: instant results from McDonald’s, Burger King, and Wendy’s.

Here’s what actually happens today: Nothing. Because these agents can’t talk to each other.

Let me explain why this matters and how Google just fixed it.

The Problem: Agents Are Trapped

Enterprises are building thousands of autonomous agents. You have agents for hiring, agents for supply chain, and agents for customer support.

But there is a catch. These agents are isolated islands. If your “Hiring Agent” needs to run a background check, it cannot just ask the “Background Check Agent.” It has to ask you. You become the manual middleman.

To connect them today, you need custom code.

• Connect 2 agents? You need 1 integration.
• Connect 50 agents? You need 1,225 integrations. This is expensive. This is slow. This does not scale.

The Solution: A2A Protocol

Google introduced a protocol called Agent2Agent (A2A), with support and contributions from more than 50 technology partners like Atlassian, Box, Cohere, Intuit, Langchain, MongoDB, PayPal, Salesforce, SAP, ServiceNow, UKG, and Workday.

What is A2A in simple terms?

A2A is an open protocol that provides a standard way for agents to collaborate with each other, regardless of the underlying framework or vendor.

Think of it like this:

Before the internet, if you wanted your computer to talk to my computer, we needed custom hardware and software that matched exactly. The internet protocol (HTTP) solved this by creating one standard language.

A2A is HTTP for AI agents.

With A2A:

• McDonald’s publishes one file saying, “Here’s how to order from me.”
• Burger King publishes one file saying, “Here’s how to order from me.”
• Wendy’s publishes one file saying, “Here’s how to order from me.”

Zomato’s agent reads these files and instantly knows how to talk to all three. Zero custom code.

How A2A Works: The Five Core Principles

While designing the protocol with partners, Google adhered to five key principles:

1. Agents Stay Independent

A2A focuses on enabling agents to collaborate in their natural, unstructured modalities, even when they don’t share memory, tools and context.

Your agent doesn’t need to know how my agent works internally. They just need to speak the same protocol.

2. Uses Web Standards Everyone Knows

The protocol is built on top of existing, popular standards, including HTTP, SSE, and JSON-RPC.

If you’ve built a REST API, you already understand A2A.

3. Security Built In

A2A is designed to support enterprise-grade authentication and authorisation, with parity to OpenAPI’s authentication schemes.

OAuth and API keys and all standard authentication methods work.

4. Handles Any Timeline

We designed A2A to be flexible and support scenarios where it excels at completing everything from quick tasks to deep research that may take hours and/or even days when humans are in the loop.

Instant tasks (“What’s 2+2?”) and multi-day workflows (“Run a background check”) both work.

5. Works With Any Content Type

The agentic world isn’t limited to just text, which is why we’ve designed A2A to support various modalities, including audio and video streaming.

Text, images, videos, PDFs, structured data so agents can exchange any format.

The Main Concepts: How It Actually Works

A2A facilitates communication between a “client” agent and a “remote” agent.

A client agent is responsible for formulating and communicating tasks, while the remote agent is responsible for acting on those tasks.

Let me break down the key pieces:

1. Agent Card (The Business Card)

Agents can advertise their capabilities using an “Agent Card” in JSON format.

Agents publish their metadata and capabilities via a Standardised JSON document called an Agent Card, usually hosted at /.well-known/agent.json.

What’s in an Agent Card?

• Name and description
• URL endpoint
• What skills it has
• What data formats it accepts
• How to authenticate

Where is it? Every agent publishes this at a standard location:

https://company.com/.well-known/agent.json

Example — McDonald’s Agent Card:

{
 "name": "McDonald's Order Agent",
 "url": "https://api.mcdonalds.com/a2a",
 "skills": [
 {
 "id": "order_food",
 "name": "Place Food Order",
 "examples": ["I want a Big Mac meal"]
 },
 {
 "id": "check_menu",
 "name": "Check Menu Prices"
 }
 ],
 "security": [{"oauth": ["read", "write"]}]
}

This tells other agents: “I’m McDonald’s agent. I can take orders and check menus. Here’s my URL. Authenticate with OAuth.”

2. Task (The Work Unit)

The communication between a client and remote agent is orientated towards task completion. This “task” object is defined by the protocol and has a lifecycle.

Tasks have lifecycle states such as submitted, working, input-required, or completed.

Task States:

• SUBMITTED → Just received
• WORKING → Being processed
• INPUT_REQUIRED → Needs more info from you
• COMPLETED → Done
• FAILED → Error occurred

3. Messages (The Communication)

Agents can send each other messages to communicate context, replies, artifacts, or user instructions.

Messages have two roles:

• “user” = from the client agent (the one asking)
• “agent” = from the remote agent (the one answering)

4. Parts (The Content)

Each message includes “parts,” which is a fully formed piece of content.

Parts: Self-contained data blocks within messages or artifacts like plain text, file blobs, or JSON.

Three types:

• Text :Plain text
• File :PDFs, images, videos
• Data :Structured JSON

One message can have multiple parts — text instructions + attached file + structured parameters.

5. Artifacts (The Results)

The output of a task is known as an “artefact”.

Artefacts are for immutable results created by the remote agent.

Think of artefacts as the final deliverables of the actual work product.

A2A vs MCP: Why You Need Both

A2A is an open protocol that complements Anthropic’s Model Context Protocol (MCP), which provides helpful tools and context to agents.

Let me make this crystal clear:

MCP = Agent-to-Tool

Tool interoperability (MCP): Agents calling structured functions, APIs, or tools.

MCP connects your agent to:

• Databases
• File systems
• APIs
• Internal tools

MCP makes ONE agent smarter by giving it tools.

A2A = Agent to Agent

Agent interoperability (A2A): Agents collaborating in natural language or mixed modalities.

A2A connects your agent to:

• Other agents in your company
• External agents (Salesforce, SAP, etc.)
• Partner agents (suppliers, vendors)
• Any A2A-compatible agent

A2A makes MANY agents work together.

Why You Need Both

Protocols create standards for interoperability. In the agentic world, two types of interoperability are crucial.

Real example: loan approval:

A LoanProcessor agent receives a loan application. It uses MCP to call a credit score API, retrieve the bank transaction history from a secure data source, and validate uploaded documents using an OCR.

That’s MCP, connecting the agent to tools and context.

Based on the structured data, the agent uses A2A to collaborate with a RiskAssessmentAgent to evaluate borrower risk, consults a ComplianceAgent to ensure the loan meets legal requirements, and hands off to a DisbursementAgent to schedule the fund transfer.

That’s A2A, which is many agents working together over the internet to solve the problem.

The pattern:

• MCP = Vertical (agent to its tools)
• A2A = Horizontal (agent to other agents)

You need both to build complete systems.

Real Example: How A2A Works End-to-End

Let me show you a complete workflow so you see exactly how this works.

Scenario: Ordering Food on Zomato

You say, “I want a burger meal under $15, delivered in 30 minutes.”

Step 1: Discovery

Zomato’s agent discovers food ordering agents by checking the standard location:

GET https://mcdonalds.com/.well-known/agent.json
GET https://burgerking.com/.well-known/agent.json
GET https://wendys.com/.well-known/agent.json

Each restaurant returns their agent card, saying what they can do.

Step 2: Authentication

Zomato reads each Agent Card to learn how to authenticate. McDonald’s uses OAuth, so:

1. Zomato requests token from McDonald’s
2. Gets access token back
3. Ready to send requests

Step 3: Send Request

Zomato sends the same request to all three:

{
 "taskId": "task-001",
 "message": {
 "role": "user",
 "parts": [
 {
 "kind": "text",
 "text": "What burger meals under $15 can you deliver to ZIP 94043 in 30 minutes?"
 }
 ]
 }
}

Step 4: Processing

Each restaurant agent:

1. Receives the task (Status: SUBMITTED)
2. Checks their menu database (Status: WORKING)
3. Calculates delivery time (Status: WORKING)
4. Prepares response (Status: COMPLETED)

Step 5: Response

McDonald’s sends back:

{
 "task": {
 "status": {"state": "completed"},
 "artifacts": [
 {
 "parts": [
 {
 "kind": "data",
 "data": {
 "meals": [
 {"name": "Big Mac Meal", "price": 12.99, "deliveryTime": "25 min"},
 {"name": "Quarter Pounder Meal", "price": 13.49, "deliveryTime": "25 min"}
 ]
 }
 }
 ]
 }
 ]
 }
}

Step 6: Aggregation

Zomato collects responses from all three, filters by your criteria, and shows:

🍔 Best burger meals under $15:

1. Burger King - Whopper Meal - $11.99 (28 min)
2. McDonald's - Big Mac Meal - $12.99 (25 min)
3. Wendy's - Dave's Single Meal - $13.49 (27 min)

What just happened:

• Three different agents from three different companies
• Built with different frameworks
• All communicated seamlessly using A2A
• Zero custom integration code

The Bottom Line

The internet of agents is here. And it speaks A2A.

To maximize the benefits from agentic AI, it is critical for these agents to be able to collaborate in a dynamic, multi-agent ecosystem. Enabling agents to interoperate with each other, even if they were built by different vendors or in a different framework, will increase autonomy and multiply productivity gains, while lowering long-term costs.

Without A2A:

• Every agent pair needs custom code
• Expensive to build
• Expensive to maintain
• Doesn’t scale

With A2A:

• Agents discover each other automatically
• Standard communication
• Works with any framework
• Scales infinitely

A2A has the potential to unlock a new era of agent interoperability, fostering innovation and creating more powerful and versatile agentic systems.

We’re moving from isolated AI tools to collaborative AI ecosystems where your customer support agent coordinates with billing, your inventory agent negotiates with suppliers, and your HR agent works with external recruiters and all automatically.

This collaborative effort signifies a shared vision of a future when AI agents, regardless of their underlying technologies, can seamlessly collaborate to automate complex enterprise workflows and drive unprecedented levels of efficiency and innovation.

Official Resources:

• A2A GitHub Repository
• Google Developer Blog
• A2A Website

Join thousands of data leaders on the AI newsletter. Join over 80,000 subscribers and keep up to date with the latest developments in AI. From research to projects and ideas. If you are building an AI startup, an AI-related product, or a service, we invite you to consider becoming a sponsor.

Published via Towards AI