Ask an engineering team how their AI agents talk to each other and the answer is usually the same: glue code someone wrote last quarter. One team’s research agent calls another team’s pricing agent over a bespoke endpoint. A vendor’s support agent cannot see your internal scheduling agent at all.
The A2A protocol exists to end that pattern. It is the interoperability layer for the agent era — the piece that lets software built by different companies, frameworks, and clouds find each other and hand off work.
| Quick answer: The A2A (Agent2Agent) protocol is an open standard, announced by Google in April 2025 and governed by the Linux Foundation, that lets AI agents from different vendors and frameworks discover each other, exchange messages, and delegate tasks. It runs on Agent Cards, Tasks, and ordinary web transport. Version 1.0 shipped in March 2026. |
Table of Contents
What Is the A2A Protocol, and Who Governs It?
The A2A protocol is an open standard that defines how autonomous AI agents discover one another, describe what they can do, and delegate tasks across organizational and framework boundaries. Google announced it on 9 April 2025 with more than fifty launch partners, then donated the specification and SDKs to the Linux Foundation on 23 June 2025, where the Agent2Agent project now provides vendor-neutral stewardship under an Apache 2.0 license.
That governance detail matters. A protocol controlled by one cloud vendor is a strategy; a protocol held by a neutral foundation is infrastructure. Enterprises will not bet a coordination layer on one company’s roadmap, which is why the transfer preceded the sharpest phase of adoption. By the project’s one-year mark in April 2026, the Linux Foundation reported more than 150 supporting organizations, over 22,000 stars on the core repository, and official SDKs in five languages: Python, JavaScript, Java, Go, and .NET.
Put simply: a tool protocol is how an agent reaches its instruments; A2A is how it reaches its colleagues.
Why Did AI Agents Need Their Own Protocol?
Modern enterprises do not run one agent. They run a forecasting agent from one vendor, a ticketing agent from another, and internal agents built on different stacks by teams that have never met. For those agents to collaborate, each pairing historically needed custom connection code — and possible pairings grow quadratically with the number of agents.
This is the agent interoperability problem, and it has a familiar shape: many producers, many consumers, no shared contract. Without a standard, nothing coordinates across a vendor or an org chart, and the promise of multi-agent AI systems stalls at the boundary of whoever wrote the integration.
A2A supplies the missing contract: a common vocabulary for discovery and delegation. An agent built on one framework can locate an agent built on another, read what it is capable of, and hand it work — with neither side writing connection-specific code. Agents built with agent frameworks such as LangGraph, CrewAI, and AG2 can now interoperate without sharing memory, runtime, or vendor.
How Does A2A Actually Work?
A2A rests on three primitives.
Agent Cards handle discovery. Each agent publishes a machine-readable JSON manifest — served by convention at code>/.well-known/agent-card.json/code> — describing its name, version, skills, supported input and output modalities, and authentication requirements. It functions like a microservice service descriptor, except the consumer is another model.
Tasks handle work. A Task is a unit of delegated work with a defined lifecycle, moving through states such as submitted, working, and input-required to a terminal state of completed, failed, canceled, or rejected. Each Task carries a unique identifier plus structured payloads of text, files, and data, so a delegating agent can track a job rather than firing a request into the dark.
Transport handles delivery. A2A rides on existing web standards rather than inventing a network layer, with bindings for JSON-RPC 2.0, gRPC, and plain HTTP+JSON. Clients consume updates by polling, Server-Sent Events streaming, or webhook, so existing load balancers, gateways, and observability tooling keep working.
Together these produce a client-remote pattern: a client agent identifies work to delegate, fetches the remote agent’s Agent Card to confirm it is a fit, submits a Task, and follows it by ID to a terminal state.
What Changed in A2A Version 1.0?
March 2026 brought the first stable, production-grade release. The official v1.0 announcement describes a web-aligned, stateless architecture on JSON+HTTP, gRPC, and JSON-RPC, plus enterprise multi-tenancy with secure isolation between callers.
Two changes matter most. The first is signed Agent Cards, which attach cryptographic signatures so a consuming agent can verify that a card genuinely belongs to the domain it claims — closing a spoofing gap that made open discovery risky for regulated workloads. The second is a deliberate migration path: v1.0 tightens the interaction protocol with breaking changes, but the Agent Card itself evolved backward-compatibly, letting an agent advertise both v0.3 and v1.0 behavior at once. Fleets migrate progressively rather than through a single cutover.
A2A has also grown a family. Companion specifications now cover payments (AP2), agent-to-user interfaces (A2UI), and commerce (UCP) — the ecosystem is standardizing the surrounding workflow, not just the message envelope.
How Is A2A Different From MCP?
This is the most-confused point in the entire agent stack, and the distinction is clean: MCP, the Model Context Protocol, connects an agent to tools and data. A2A connects an agent to other agents. They are complementary layers, not competitors.
The governance story reinforces the split. Anthropic released MCP in November 2024 and donated it to the Agentic AI Foundation in December 2025 — a separate Linux Foundation body from the Agent2Agent project. Two neutral homes, two distinct layers, one umbrella.
| Aspect | MCP | A2A |
| Connects | Agent to tools and data | Agent to other agents |
| Originated | Anthropic, November 2024 | Google, April 2025 |
| Solves | Tool and data integration | Discovery and task delegation |
| Key primitives | Tools, resources, prompts | Agent Cards, Tasks |
| Governance | Agentic AI Foundation | Agent2Agent project |
| Stable release | Iterative spec revisions | v1.0, March 2026 |
The relationship is clearest in motion: an orchestrating agent uses A2A to delegate a job to a specialist, and that specialist uses MCP to call the tools that finish it. Neither replaces the other. One fair critique remains — some engineers argue A2A adoption has trailed its launch hype, partly because MCP already handles stateful task tracking, creating overlap at the edges.
What Does A2A Look Like in Production?
Consider Priya Raghavan, a supply chain systems lead at a mid-size electronics manufacturer. Her team runs an internal demand-forecasting agent; their largest component supplier runs its own inventory agent, on a different framework, in a different cloud tenancy. Before A2A, reconciling a forecast against supplier availability meant a nightly CSV export, a shared SFTP directory, and a Tuesday morning phone call when the numbers disagreed.
Priya’s team published an Agent Card for the forecasting agent and pointed it at the supplier’s card. The forecasting agent now submits a Task — check availability for these twelve part numbers across the next two quarters — and tracks it to a completed state. The supplier’s agent answers with structured availability data and lead times. Neither company wrote an integration against the other’s internals.
The outcome Priya reports is unglamorous and valuable: the reconciliation cycle dropped from overnight to minutes, and the Tuesday call became an exception path rather than a standing meeting. That is the shape of most real A2A deployments in 2026 — coordination across an organizational boundary that previously required a human courier. The Linux Foundation names supply chain, financial services, insurance, and IT operations as the deepest production verticals.
How Do You Adopt A2A Safely?
Start by publishing a card, not by rewriting your architecture. Pick one agent other teams already ask for, describe its skills accurately in an Agent Card, and expose it behind your existing gateway. Because A2A is web-native, your current authentication, rate limiting, and logging mostly apply unchanged.
Security deserves genuine attention, because A2A is by design an inbound delegation surface: you are letting external software submit work into your systems. Sensible defaults are OAuth 2.0 client-credentials or mutual TLS, secrets rotated in a managed vault, authorization re-validated at every interaction rather than only at discovery, and Agent Card permissions scoped to the minimum a caller needs. Signed cards add domain verification on top. Treat every delegated Task the way you would treat a request from an unauthenticated internet client, because functionally that is what it is.
Teams already invested in modern AI coding tools will find the SDK path short — the protocol is small enough to read end to end in an afternoon.
How we compare: our assessments draw on the published A2A specification, Linux Foundation and Google announcements, and adoption reporting through July 2026. We prioritize primary sources over vendor marketing and flag contested claims rather than repeating them.
Disclosure: TechieHub may earn a commission from some links on this page. This never influences our editorial assessments or rankings.
Frequently Asked Questions
Who created the A2A protocol?
Google announced Agent2Agent on 9 April 2025 alongside more than fifty launch partners. On 23 June 2025 it donated the specification and SDKs to the Linux Foundation, which established the Agent2Agent project for vendor-neutral governance under an Apache 2.0 license, so no single company controls the standard today.
What are Agent Cards in A2A?
Agent Cards are A2A’s discovery mechanism. Each agent publishes a machine-readable JSON manifest, served by convention at /.well-known/agent-card.json, describing its skills, supported input and output modalities, and authentication requirements. Version 1.0 adds signed Agent Cards, using cryptographic signatures so consumers can verify the publishing domain.
Is A2A the same as MCP?
No. MCP connects an agent to tools and data sources; A2A connects an agent to other agents. They are complementary layers rather than competitors, and production multi-agent systems commonly run both. A typical flow uses A2A to delegate a task, then MCP inside the receiving agent to call the tools that complete it.
What version of A2A should I build against?
Build against version 1.0, released in March 2026 as the first stable, production-grade specification. It introduces breaking changes to the interaction protocol, but the Agent Card evolved backward-compatibly, so an agent can advertise both v0.3 and v1.0 support at once and migrate clients progressively.
How widely adopted is A2A in 2026?
The Linux Foundation reported more than 150 supporting organizations in April 2026, including AWS, Cisco, Google, IBM, Microsoft, Salesforce, SAP, and ServiceNow. A2A is integrated into Azure AI Foundry, Copilot Studio, Amazon Bedrock AgentCore, and Google Cloud, with production deployments across four named verticals.
Do I need A2A if I only run one agent?
Probably not. A single agent calling tools is well served by MCP alone. A2A earns its keep when multiple independent agents — especially across different frameworks, teams, or companies — must discover each other and delegate work. Adopt it when cross-agent collaboration is a genuine requirement, not a hypothetical one.
Conclusion
A2A answers a narrow question well: how does one agent find another and hand it a job. That narrowness is the point. By keeping the specification small, riding existing web transport, and living under neutral governance, it became something enterprises could adopt without betting on a vendor’s roadmap — and 150-plus organizations plus a stable v1.0 suggest the bet paid off.
If you are building anything with more than one agent in it, the takeaway is simple. Use MCP where your agent reaches for tools, use A2A where it reaches for other agents, publish an honest Agent Card, and treat inbound Tasks with the suspicion you would give any public endpoint. The coordination layer is settled; the interesting work is what you build on top of it.
