0:01Let's start with an agent that already uses MCP. Our agent keeps a list of MCP servers.
0:06When it connects it learns what each server offers, and its model calls those tools as it needs them.
0:11Another team has an agent of its own, built by different people on a different framework, and we want ours to hand it work.
0:18From our side it looks like one more thing to call, so the obvious first move is to wrap it as a tool.
0:22A request goes in as one string and the answer comes back as one string. Our model calls it like any other tool and waits, and that works.
0:31MCP can even track a long call and ask the user for more, so duration and questions are not the problem.
0:37The whole contract is that one parameter. Everything else about working with an agent, the wrapper has to invent for itself.
0:44Let's name what it invents.
0:45How we find the agent and what it can do. How the work is tracked, how it asks us for more, and how the results arrive.
0:53Every team answers those four differently. Let's look behind that card.
0:57The card opens onto a whole agent, and everything inside it belongs to that team.
1:02It has a model of its own and tools of its own, and that team chose all of them.
1:07Its model calls its tools, reads what comes back, and calls again. That loop is how it plans for itself.
1:14We hand it a job, and that is all we send. The message goes over once.
1:17The work runs in there and may take several rounds. We chose none of those steps, the agent did.
1:23Then the result comes back to us, once. A delegation has three separate moments, and a call does not separate them.
1:29From our side none of that was visible, and it does not need to be.
1:33All we get is what crosses the connection. Where the work stands, a question if it has one, and the result.
1:39Two connections leave our agent, and they are different in kind.
1:43The connection to a server is a call. Our model picks the function and the arguments, and the contract is a schema.
1:49Now the connection to the agent.
1:51That one is a delegation. We hand over a goal, it plans its own steps, and the contract is a description of what it can do.
1:58The same program could be behind either. What differs is the pattern it was designed for, and the four things the wrapper kept inventing follow from that.
2:07Give those four things one agreed form, and there is nothing left to invent. The wrapper we would have written goes away.
2:13In its place is one agreed connection. It says how an agent is found, how its work is tracked, how it asks back, and how results arrive.
2:22Our agent implements the agreement once, and theirs serves it once. With more teams on either side, that is still one implementation each.
2:30The job goes over one way, in the agreed form, whatever framework either agent runs on.
2:35The result comes back one way. It is the same interaction as before, and now any two agents can have it.
2:41The agreement we just drew has a name. It is called agent to agent.
2:45The name says what it is for, which is one agent handing work to another. Google published it in twenty twenty five, and since twenty twenty six it has been in the Agentic AI Foundation, alongside MCP.
2:56Whatever each agent is built on, finding it, tracking its work, its questions back, and its results now have one agreed form. That is more than one video can cover, so this one starts a series.
3:08This series has three sections.
3:10The first is the idea.
3:12We start with how one agent finds another, and what it learns about it before sending anything.
3:17Then what actually travels between the two while a job is being done.
3:21And then we use one, an agent somebody else wrote, from a client of our own.
3:25The second section is where we build.
3:27We write the smallest possible version of our own agent, a stock analyst that writes a short brief. It stays with us for the rest of the series.
3:35Then we watch a job take time, and watch it stop to ask a question.
3:39Then the messages between the two sides as they are actually sent, and where agent to agent meets MCP inside our analyst.
3:45The third section is where it runs for real.
3:47One agent handing work to several others.
3:50What you give away when you hand a job to someone else's agent.
3:53And an agent that stays reachable after its caller has gone.
3:57Next time we start with the first thing our agent has to do.
3:60It has to find the other agent, and learn what that agent can do, before it sends any work.

What Is A2A, and Why Isn't It Just MCP?

Created by Abhyuday DesaiPublished 2 Oct, v1Runs 4 min 11 sec

1 view

About this video

In Episode 01 of A2A Explained, we start from the picture MCP left us with: our agent, its list of servers, tools arriving at connect time. Then another team has an agent too, built by different people on a different framework, and we want ours to hand it work. The honest first answer is to wrap it as a tool with one text parameter. The episode follows what that wrapper would have to invent, and why that list is a protocol.

You'll learn how to:

See where a tool call stops being enough: finding the other agent, learning what it can do, tracking work that takes time, answering its questions, getting results back
Tell a call from a delegation: behind the card is a whole agent that plans for itself
Understand how one standard between agents replaces every hand-written wrapper, once per side
Read the name: agent to agent, and where the protocol came from
See the series roadmap: the idea first, then building an agent

This video is for developers who have watched MCP Explained or know its vocabulary. No A2A knowledge is needed.

What changed

v102 Oct 2026abhydesai4 min 11 sec484dddd

First published version.

1 view0 likes on this version