Title: A2A Protocol Explained: How AI Agents From Different Vendors Communicate

By 2025, the average large enterprise had an HR agent from one vendor, a finance agent from another, and a couple of homegrown agents in between each capable on its own, all of them mute together. Every integration was a custom, brittle one-off. The A2A protocol Agent2Agent, announced by Google in April 2025 and now governed by the Linux Foundation is the open standard built to fix exactly that: a shared language so agents from any vendor can find each other, delegate work, and collaborate.
This guide covers what the agent-to-agent protocol is, how it works under the hood, how it differs from MCP (the comparison everyone confuses), and whether it's worth learning in 2026.

What Is the A2A (Agent2Agent) Protocol?

A2A (Agent2Agent) is an open, vendor-neutral agent communication protocol that lets AI agents built on different frameworks, by different vendors, discover each other, delegate tasks, exchange messages, and collaborate securely at scale without ever exposing their internal logic, memory, or tools.

The key design idea is opaque agents. A2A treats every agent as a black box: agents cooperate through the protocol's surface cards, tasks, messages never by sharing internals. Your orchestrator doesn't get to peek inside the airline's agent, and the airline's agent doesn't see your prompts. That's precisely what makes cross-vendor collaboration safe enough for enterprises to adopt.

Two analogies, both precise: HTTP let any browser talk to any web server, regardless of who built either side. UPI let any payments app talk to any bank. The A2A protocol aims to do the same job for AI agents a common wire format so the "who built it?" question stops mattering.

(Quick grounding: an "agent" here is an LLM-powered system that can plan multi-step work and call tools on your behalf if that concept is new, see how AI agents actually work in practice first, then come back.)

Build an AI-First Career, Master the Complete Skillset

Choose from our industry-leading programs designed for career success

NSDC Certified

Modern Software and AI Engineering Program

Master full-stack development with AI integration

12 MonthsDuration

AI-LedCurriculum

Career SupportSupport

+1000 more

Go to Program

NSDC Certified

Modern Data Science and ML with specialisation in AI

Advanced data science techniques with AI specialization

12 MonthsDuration

AI-LedCurriculum

Career SupportSupport

+1000 more

Go to Program

NSDC Certified

Advanced AIML with Specialisation in Agentic AI

Deep dive into AIML with focus on Agentic systems

12 MonthsDuration

AI-LedCurriculum

Career SupportSupport

+1000 more

Go to Program

NSDC Certified

DevOps, Cloud & AI Platform Engineering

Build and manage AI-powered cloud infrastructure

12 MonthsDuration

AI-LedCurriculum

Career SupportSupport

+1000 more

Go to Program

NSDC Certified

AI Engineering Advanced Certification by IIT-Roorkee

Premier AI engineering certification from IIT-Roorkee

3 MonthsDuration

AI-LedCurriculum

Career SupportSupport

Go to Program

NSDC Certified

AI Forward Deployed Engineer Program

Full-stack engineering, production AI and client-facing consulting

12 MonthsDuration

AI-LedCurriculum

Career SupportSupport

+1000 more

Go to Program

The interoperability problem A2A solves

Without a shared protocol, connecting N agents means N×N custom integrations: mismatched payload formats, no common way to track long-running work, retries that quietly duplicate actions. I've watched two teams spend a sprint wiring a "simple" hand-off between their agents the demo worked in a week, and then reality broke it daily: one agent's timeout was the other's duplicate expense approval.

Now picture employee onboarding, a classic real-world AI agent examples scenario: an HR agent living in Workday, an IT-provisioning agent in ServiceNow, and a payroll agent in SAP all need to coordinate for one new joinee. Today that's three vendors who will never share code. Multi-agent systems are only as useful as their weakest connection and vendor lock-in is the tax you pay for every weak connection.

A short history: from Google announcement to Linux Foundation standard

Google announced Agent2Agent on 9 April 2025 with more than 50 supporting partners Atlassian, Salesforce, SAP, ServiceNow, LangChain, PayPal, and others. Worth pausing on: the launch partner list included TCS, Infosys, Wipro, and HCLTech India's four IT majors showing up on day one of a new standard (something no SERP competitor mentions, and which matters a lot if you work, or plan to work, in Indian tech services).
Two months later Google donated the protocol to the Linux Foundation for vendor-neutral governance so while people still search for and say "Google A2A," the protocol itself is now community property. The timeline since has been fast:

How the A2A Protocol Works: Core Concepts

Two roles frame everything: the A2A client (the agent asking usually your orchestrator) and the A2A server, a.k.a. remote agent (the agent doing the work). The whole a2a architecture is five objects passed between those roles. Follow one running example through all of them: a travel assistant that books a Delhi→Bengaluru trip by delegating to an airline agent and a hotel agent.

Agent Cards: how agents discover each other

An Agent Card is a JSON metadata document an agent publishes typically at a well-known URL (/.well-known/agent-card.json) describing its identity, skills, service endpoint, supported transports, and authentication requirements. Client agents read it to discover capabilities and decide whether to delegate work. Think of it as the agent's résumé: read before you hire.

No database, no registry call, no sales intro the client reads this JSON and knows whom it's dealing with. (Since v1.0, cards can also be cryptographically signed JWS-based "Signed Agent Cards" so a client can verify an agent really belongs to who it claims to. Identity for agents, which enterprise security teams very much wanted.)

Tasks, messages, parts, and artifacts

Once hired, work flows through four objects:

The object that deserves your attention is the task. Unlike a stateless API call, a task has a defined lifecycle with named states — submitted, working, input-required, auth-required, completed, failed, canceled, rejected (plus unknown as a fallback). Tasks can run for minutes or days deep research, human approvals, fare holds and the state machine is what lets both sides stay synchronized the entire time. An agent that stalls waiting for your meal preference isn't broken; it's sitting politely in input-required.

Hiring Partners:

GoogleAmazonMicrosoftFlipkartAdobe1200+ more

Under the hood: JSON-RPC, gRPC, SSE, and push notifications

The official specification (v1.0, verified 06 Aug 2026) deliberately reuses boring, proven web plumbing. It defines three interchangeable protocol bindings JSON-RPC 2.0 over HTTP(S), the common default; gRPC for high-throughput internal systems; and HTTP+JSON/REST for teams that think in REST verbs.
The data model (cards, tasks, parts) is transport-agnostic; an agent advertises which bindings it speaks right inside its Agent Card.

Because tasks are long-running, clients need updates without hammering the server. Three options: polling (call GetTask on an interval fine for quick jobs), streaming via Server-Sent Events (SSE) (the server pushes live status: searching fares → holding seat), and push notifications (webhook callbacks for very long tasks: "ping me when the visa check clears").

Security follows the same philosophy: nothing new invented. OAuth 2.0, OpenID Connect, API keys, and mutual TLS declared in the Agent Card do the work, so A2A slots into enterprise security that already exists instead of demanding new infrastructure.

A2A in Action: A Multi-Agent Example, Step by Step

Most explainers stop at object definitions. Here's one complete a2a protocol example in plain English our travel assistant booking that Delhi→Bengaluru trip through the airline agent from H2-2:

• Discovery. The travel assistant (client) fetches the airline agent's Agent Card from its well-known URL, checks the flights.search skill, confirms OAuth, and sees that streaming is supported.
• Kick-off. The client sends a message to the agent's endpoint, creating a task: "Book a DEL→BLR flight for next Friday, morning preferred, budget ₹8,000."
• Streaming updates. Over SSE, status events stream back: working searching fares… found 3 options under ₹7,500… holding a seat on the 9:15.
• Human-in-the-loop pause. The remote agent flips the task to input-required: "Meal preference? Window still available?" The client relays the question to the traveler and replies with a new message: "Vegetarian, window, confirm."
• Completion. The task moves to completed and returns an artifact: the itinerary object plus the e-ticket PDF (a file part).
• Composition. The assistant repeats steps 1 - 5 with the hotel agent own card, own auth, own task then assembles flight + hotel into one itinerary for the traveler.

Notice what the protocol bought us: discovery, delegation, long-running state, a mid-task human pause, and structured outputs with zero custom integration code between two vendors' agents. In the pre-A2A world, each of those was a bespoke connector.

One accuracy note: where the orchestration logic itself lives LangGraph, Google ADK, CrewAI, or Microsoft Agent Framework is a framework choice you make separately; A2A is only the wire between agents. It slots into the communication layer of your broader agentic AI architecture and its layers.

Who's Adopting A2A and Why It Matters

The one-year numbers, straight from the Linux Foundation's April 2026 report: support grew from 50+ organizations at launch to 150+ including AWS, Cisco, Google, IBM, Microsoft, Salesforce, SAP, and ServiceNow. The core repo crossed 22,000 GitHub stars, and the SDK ecosystem went from Python-only to five production-ready languages.

Clouds are baking it in: Microsoft integrated A2A into Azure AI Foundry and Copilot Studio, and AWS added support through Bedrock AgentCore. Production verticals named: supply chain, financial services, insurance, and IT operations. Diverse agents say, LangGraph and CrewAI can now delegate sub-tasks to each other without sharing internal memory. An adjacent sibling, the Agent Payments Protocol (AP2), extends the same interoperability case to agent-driven transactions.

The India angle deserves its own paragraph: TCS, Infosys, Wipro, and HCLTech were launch partners, which means A2A-based agent work is arriving inside the companies that employ the largest share of Indian software engineers not as a Silicon Valley abstraction but as project work on enterprise accounts. Microsoft learning platforms already ship A2A integration docs, a decent proxy for where enterprise skilling budgets are pointed.

The honest counterweight, because trust beats cheerleading: the A2A protocol is young. v1.0 only shipped in March 2026; agent-discovery registries and cross-organization trust models are still maturing (the roadmap explicitly includes registry work); and most production use today lives inside enterprise boundaries rather than across the open internet. Betting on it is reasonable; assuming it's finished is not.

Getting Started With the A2A Protocol: SDKs and First Steps

Everything lives in the a2aproject organization on GitHub: the spec, the official A2A SDK packages for Python, JavaScript/TypeScript, Java, C#/.NET, and Go, and sample agents. Google's Agent Development Kit (ADK) speaks A2A natively, and LangGraph, CrewAI, and Microsoft Agent Framework interoperate so you pick the agent framework and the framework talks the wire.
A sane first weekend, in four steps:

• Read the spec's core-objects section an hour, and the five objects from H2-2 will click.
• Run a sample server + client from the samples repo as-is; watch the JSON-RPC traffic.
• Inspect the Agent Card exchange fetch the card yourself with curl and read every field.
• Wrap one of your own agents as an A2A server, with one narrow skill.

One practitioner tip that saves pain later: expose one narrow skill per Agent Card at first. Kitchen-sink agents twelve skills, mixed input modes get painful fast when versioning, auth scoping, and blame assignment arrive. Cards are cheap; keep them focused. (A hands-on a2a protocol tutorial, beyond this orientation, is a natural next read once the samples are running.)

Why the A2A Protocol Matters for Your AI Engineering Career

For a decade, "can you build a REST API?" was baseline interview material for backend roles. Protocol literacy is climbing the same ladder for agentic roles: job posts increasingly say "multi-agent systems," and interviewers increasingly probe how you'd make two agents coordinate safely. Knowing what an Agent Card is and why input-required exists signals you've thought about agents that ship, not agents that demo.
Self-assessment checklist for working with A2A:

• HTTP/REST fundamentals the bindings assume them
• JSON and JSON-RPC the payload formats
• Async patterns SSE streaming and webhooks for long tasks
• Auth basics OAuth 2.0 / OIDC flows
• One agent framework LangGraph, ADK, or CrewAI
• System design basics timeouts, retries, state

If three or more boxes tick, A2A will feel like "familiar plumbing with new nouns." If not, the honest path is fundamentals first: an agentic AI roadmap sequences exactly this LLM and agent basics, then frameworks, then interoperability and production concerns.

And the demand signal is close to home: with India's IT majors inside from launch day, enterprise agent projects will need engineers fluent in interoperability, not just prompting consistent with India AI workforce trends showing agentic-AI skills among the fastest-growing demands in Indian tech hiring.