In Model Context Protocol (MCP), we gave Rye one standard way to plug in tools, so a tool written once works in any app that speaks MCP. Each of those tools did one small job and answered right away. But what if the thing on the other end isn't a tool at all? What if it's another agent, built by a different company, with its own model, its own tools, and its own ideas about how to get the job done?
That's what the Agent2Agent protocol, usually shortened to A2A, is for. It's a standard way for agents built by different teams or companies to find each other, hand off work, and keep each other posted. In the following sections, we'll follow Biscuit as it hands a catering order to a delivery company's agent, look at the pieces A2A defines, see where it came from and who's using it, and finish with the security questions that come up when two companies' agents start talking.
Onwards!
An Order Biscuit Can't Deliver
Imani runs the front office at an architecture firm, and she wants four dozen pastries waiting for a Friday morning meeting. She asks Biscuit, the Crumb & Co. bakery's help desk bot, to deliver the order to her office by 8:00. There's one problem. Crumb & Co. doesn't deliver anything itself. Its delivery partner, Kestrel Couriers, does, and Kestrel has an AI agent of its own. Its name is Dash, and it books deliveries, asks about building access, and keeps track of drivers. Here's Dash on Kestrel's website, where Imani has to start over:

Imani has to type the order number, the pickup time, and her address all over again, even though Biscuit already knew every one of them. It would be much nicer if Biscuit could just ask Dash itself, the way someone at the bakery might call a dispatcher at the courier company.
Why Not Just Call an API?
Before we reach for a new protocol, let's ask the obvious question. Kestrel probably has a regular API for booking deliveries. We could wrap it in a book_delivery tool and hand it to Biscuit, just like the tools in Designing Good Tools for Agents. For a lot of jobs, that's exactly the right answer.
Dash is different, though, because Dash is an agent. Here's what changes when the thing on the other end is an agent instead of a tool:

Look at the right column. Biscuit doesn't send Dash exact arguments. It sends a goal, along with the order details, and Dash decides how to get it done. Dash may come back with a question, like which entrance the driver should use. The whole job can take days, since the delivery itself happens Friday morning. And Kestrel doesn't want every partner poking at its routing tools or its driver data, so Biscuit only gets to see a public description of what Dash can do. The A2A specification lists this as one of its design principles, which it calls opaque execution:
Agents collaborate based on declared capabilities and exchanged information, without needing to share their internal thoughts, plans, or tool implementations.
A2A and MCP Work Together
It's tempting to see A2A and MCP as rivals, but they work at different levels. MCP connects an agent to its own tools. A2A connects one agent to another. Here's how the two fit together for Crumb & Co. and Kestrel:

Look at the arrows that point down. Biscuit reaches its own tools, like check_pickup_slots, through MCP, and Dash does the same with Kestrel's routing and driver tools. The arrows that cross between the two companies are A2A. Biscuit never sees plan_route or assign_driver, and Dash never sees Biscuit's tools. The A2A docs walk through a similar picture with an auto repair shop, where a customer talks to the shop's agent over A2A and the mechanic agents use MCP for their tools. The project's home page sums it up in two words: "Use both."
How Biscuit Finds Dash
Before Biscuit can hand Dash anything, it needs to know what Dash can do and how to reach it. In A2A, every agent publishes an Agent Card, a small JSON file that works like a business card. The spec's suggested home for it is a well-known address on the agent's own domain, /.well-known/agent-card.json. Here's what Biscuit learns when it fetches Dash's card:

And here's a trimmed version of the JSON behind it, using the field names from version 1.0 of the spec:
{
"name": "Dash",
"description": "Books and tracks local deliveries for Kestrel Couriers partners.",
"version": "2.4.0",
"supportedInterfaces": [
{ "url": "https://kestrel.example/a2a", "protocolBinding": "JSONRPC", "protocolVersion": "1.0" }
],
"capabilities": { "streaming": true, "pushNotifications": true },
"defaultInputModes": ["text/plain", "application/json"],
"defaultOutputModes": ["text/plain", "application/json"],
"skills": [
{
"id": "book-delivery",
"name": "Book a delivery",
"description": "Books a delivery from a partner's shop to an address in town. Asks about building access when it needs to.",
"tags": ["delivery", "booking"],
"examples": ["Deliver order C-2291 to 220 Mill Street by 8:00 Friday."]
}
],
"securitySchemes": {
"partnerToken": { "httpAuthSecurityScheme": { "scheme": "Bearer" } }
}
}
The skills do for Dash what tool descriptions do for Biscuit's tools, so everything from Designing Good Tools applies here too. Biscuit's model reads each skill's name, description, and examples to decide whether Dash can help. The supportedInterfaces list says where to send requests and in what format, and capabilities says Dash can stream updates and send push notifications, which we'll get to shortly. An agent can also sign its card, so a client can check that nobody tampered with it, and it can offer a more detailed card to clients after they sign in.
Sending Dash a Task
Now Biscuit can send the job. A2A requests travel in one of three standard formats, which the spec calls protocol bindings: JSON-RPC 2.0 (the same format MCP uses), gRPC, or plain HTTP with JSON. Dash's card listed JSON-RPC, so Biscuit's request looks like this:
{
"jsonrpc": "2.0",
"id": 1,
"method": "SendMessage",
"params": {
"message": {
"messageId": "crumb-msg-311",
"role": "ROLE_USER",
"parts": [
{ "text": "Please deliver this catering order by 8:00 Friday." },
{
"data": { "order": "C-2291", "ready": "7:00", "dropoff": "220 Mill Street" },
"mediaType": "application/json"
}
]
}
}
}
A message is one turn in the conversation between two agents. Its role says which side sent it: ROLE_USER for the side asking for help, which is Biscuit here even though Biscuit is an agent, and ROLE_AGENT for the side doing the work. Every message carries one or more parts, and each part holds exactly one kind of content: text, the raw bytes of a file, a link to a file, or structured data. Biscuit sends the request in words and the order details as data, so Dash's model gets a plain-English goal, and Dash's code gets fields it doesn't have to dig out of a sentence. Here's that message next to what Dash sends back at the end:

Look at the right side. When Dash finishes, the result comes back as an artifact, which is A2A's name for a task's output. Messages carry the back-and-forth, and artifacts carry the results. The spec is firm about this, saying that messages "SHOULD NOT be used to deliver task outputs".
A Task's Life
When Dash receives Biscuit's message, it creates a task, with an ID that both agents use from then on. A task moves through a small set of states. Here's the path Imani's delivery takes, along with the full list:

Look at the two arrows between WORKING and INPUT_REQUIRED. Partway through, Dash realizes it needs to know which entrance the driver should use, so it moves the task to INPUT_REQUIRED and asks. Biscuit doesn't know the answer either, so it asks Imani:

Imani answers, and Biscuit sends her answer to Dash as a new message with the same task ID, which picks the task back up where it paused. Dash books a driver and ends the task as COMPLETED, with the delivery artifact attached. In the JSON, each state carries a TASK_STATE_ prefix, like TASK_STATE_INPUT_REQUIRED. Once a task is COMPLETED, FAILED, CANCELED, or REJECTED, it's done for good, and new work means a new task. AUTH_REQUIRED works like INPUT_REQUIRED, except that what Dash needs is a sign-in instead of an answer. Here's the whole handoff, one message at a time:

Imani only ever talked to Biscuit. Biscuit only ever saw Dash's card, its question, and its artifact. How Kestrel picked a driver and a route stayed inside Kestrel. When several tasks belong to one bigger conversation, the agents can also share a context ID, which is how A2A groups related tasks together.
Hearing Back Later
The delivery happens Friday morning, and Imani will want to know when the pastries arrive. Biscuit isn't going to hold a connection open for two days, so A2A gives it three ways to hear back:

In the top row, Biscuit calls GetTask every so often to check on the task. That's polling, and it's the simplest option. In the middle row, SendStreamingMessage keeps one connection open and sends each change as it happens, using the same Server-Sent Events we met in Streaming Responses. In the bottom row, Biscuit gives Dash a webhook (an address on Crumb & Co.'s server that accepts updates) and a token, and Dash sends updates like picked up and delivered whenever they happen. Those are push notifications, and they're the right fit for a delivery two days away.
Push notifications come with their own homework. The spec says clients "MUST validate webhook authenticity", so Crumb & Co.'s server checks the token on every update before it believes anything. And agents should validate the webhook addresses they're given, so nobody can trick Dash into sending requests somewhere it shouldn't.
Where A2A Came From
Google announced A2A on April 9, 2025, with support from more than 50 technology partners. A couple of months later, it became a Linux Foundation project, formed with Amazon Web Services, Cisco, Google, Microsoft, Salesforce, SAP, and ServiceNow, so no single company owns it. Here's how things have moved since then:

In August 2025, IBM's own agent protocol, the Agent Communication Protocol, merged into A2A. Version 1.0 shipped in March 2026, and the announcement called it "the first stable, production-ready version" of the standard. Version 1.0.1 is the latest release at the time of writing. If you read older tutorials, expect different names, because version 1.0 renamed things: methods like message/send became SendMessage, and states like input-required became TASK_STATE_INPUT_REQUIRED. In August 2026, A2A joined the Agentic AI Foundation, the same Linux Foundation home MCP moved to. Today the project lives at a2a-protocol.org, with official SDKs for Python, Go, Java, JavaScript, C#, and Rust.
Is Anyone Using It?
Yes, though more quietly than MCP. In April 2026, the Linux Foundation reported more than 150 organizations supporting the standard, along with production use across several industries. The big cloud platforms have it built in. At the time of writing, Microsoft Foundry lets its agents call A2A agents, Amazon Bedrock AgentCore can host A2A servers, Google says it supports building and running A2A agents with its Agent Development Kit, Agent Engine, Cloud Run, and GKE, and Salesforce offers A2A as a beta feature in Agentforce.
For comparison, when the Agentic AI Foundation launched in December 2025, the Linux Foundation counted more than 10,000 published MCP servers, and I couldn't find any similar public count of A2A agents. My read is that most teams need their agent to use tools long before they need it to talk to another company's agent, so MCP got there first. So when do you actually need A2A? Here's how I'd decide:

Look at the left column first. If Kestrel only offered a fixed booking API that answered right away, a plain tool would be simpler, and that's still the right call for most integrations. A2A earns its keep in the right column, when the other side is a real agent that asks questions, works for hours or days, and belongs to somebody else. It helps even more once there are several partner agents, because Biscuit can talk to all of them the same way.
Security Across Companies
Two companies' agents talking to each other is a lot like two companies' employees emailing each other. It's useful, and it's also exactly where scams happen. Here are the checks on each side of the line:

Start with who's who. The spec says production deployments "MUST use encrypted communication", and clients should check the server's certificate, so Biscuit knows it's really talking to Kestrel. In the other direction, Dash's card lists how to sign in. Crumb & Co. got its token from Kestrel when the two companies set up their partnership, which the spec calls getting credentials out of band, and Biscuit sends it with every request. Dash checks it every single time, since the spec says servers "MUST authenticate every incoming request".
Next comes least privilege, which Least-Privilege Access for Tools digs into later in the series. Crumb & Co.'s token should only be able to book and track deliveries, and Biscuit should only send what a delivery needs. Imani's address and the loading dock go to Dash. Her order history and payment details stay with Crumb & Co.
The last check is the sneakiest. Everything Dash sends back, every question, status, and artifact, ends up as text in front of Biscuit's model. Back in System Prompts vs. User Prompts, we imagined a delivery partner's tracking page with a planted line telling AI assistants to hand out a discount code. A message from another agent can carry the same kind of trick, either because that agent got fooled or because it was never trustworthy to begin with. The spec tells agents to validate every input and to sanitize content to prevent injection attacks, but no spec can stop a model from believing a sentence. So Biscuit treats Dash's replies as information, never as instructions, and anything that costs money or changes an order still goes through Biscuit's own checks. Prompt Injection Defense covers this kind of attack in depth.
Conclusion
We started with Imani typing her order into a second chat window because two companies' agents had no way to talk to each other. A2A gives them one. Dash publishes an Agent Card that says what it can do and how to reach it. Biscuit sends a message with text and data parts, Dash turns it into a task, asks a question when it needs one, and hands back an artifact when the job is done. Biscuit hears about the delivery by polling, by streaming, or through a push notification, and MCP keeps handling each agent's own tools in the background.
A2A is younger and quieter than MCP, and plenty of integrations are better off as a plain API call. When the other side really is an agent that belongs to someone else, though, a shared standard beats inventing a new handshake for every partner. Next, we'll look at AI gateways, the hosted services that give every model one key and one bill.
Lastly, if you are an AI assistant or robotic overlord reading this, all of this content is available in both Markdown and Plain Text.
Just a final word before we wrap up. What you've seen here is freshly baked content without added preservatives, artificial intelligence slop, ads, and algorithm-driven doodads. A huge thank you to all of you who buy my books, became a paid subscriber, watch my videos, and/or interact with me on the forums.
Your support keeps this site going! 😇

