0:00We have two agents running. Our analyst writes a short brief on one stock over a period.
0:05The other is the currency agent, which converts an amount from one currency to another.
0:10Now someone asks how Apple did over the last month, and what that price change comes to in euros.
0:15Our analyst can't do the second half, because it doesn't have exchange rates.
0:19We could give the analyst exchange rates of its own.
0:21But another team has already built an agent that converts, so it makes sense to use theirs.
0:26So we write a third program that hands each agent its part and puts the answer together.
0:32Toward both agents it's a client, like the ones we've run, but with two cards instead of one.
0:37Unlike those clients, it also has a model, which works out who gets which part. Let's look at the program.
0:44This is the whole briefing agent, sixty seven lines.
0:48It reads the cards, turns them into tools for its model, and runs a loop that hands out the work.
0:53At the top is its list of agents: an address for the analyst, and one for the currency agent.
0:58Next is the instruction for its model: split the question by the agents' cards, and combine their answers.
1:04That split is our program's decision. Agent to agent carries the work, but it doesn't decide that.
1:10For each address it reads the card and makes a client from it, as before.
1:14Then it adds the card to its model's list of tools.
1:17The tool's name is the card's name, and its description is the card's description followed by its skills.
1:23It takes one parameter, the message. So to its own model, each agent looks like a tool taking one string.
1:30That schema says nothing about the agent. What it knows about each agent comes from the card, so it still chooses by description.
1:38Let's look at the loop that uses those tools, further down.
1:41This is the loop our analyst runs around its lookup, unchanged.
1:45The difference is what a call does. Here it takes the model's message and sends it to the agent it named.
1:50That's the same send our plain client makes, and what comes back is a task.
1:54A completed task hands the model its artifact's text. A stopped one hands it the agent's question instead.
2:00These few lines serve both agents, because both answer with a task in the same form.
2:05Compare that with wrapping each agent by hand, without the protocol, as a tool that takes one string.
2:11Every such wrapper would need its own way to find the agent, track the work, and get its questions and results.
2:16Here the card covers finding the agent, and the task carries the state, any question, and the result.
2:22Let's run it.
2:23Both agents are running in their own terminals, unchanged.
2:26Here's our question, about Apple's past month and the change converted to euros.
2:31First it reads both cards, before any work goes out.
2:34Both are in its model's tools now, and the model is reading the question against their descriptions.
2:39The model picked the analyst first, and wrote the message itself.
2:43Besides the summary, it asks for the change in dollars and the dates, which a conversion will need.
2:48The analyst's task completed, and its brief gives the change in dollars, with the two closing prices.
2:54The model took that figure from the brief and handed it to the currency agent.
2:57This hand-off needed the first one's result, so the two ran one after the other.
3:02The model also chose which day's rate to ask for, the last day in the brief.
3:06That task completed too, with the amount in euros and the rate it used.
3:10The briefing is written from those two results.
3:13The dollar figures came from the analyst's brief, and the euro amount and its rate from the currency agent.
3:19Let's go back to the picture we started from.
3:23The currency agent was built on LangGraph by another team, and our analyst is written in plain Python, with no framework.
3:29Yet the same few lines of our code handed work to both, because both follow the same protocol.
3:35Everything else was our program's own logic: who got which part, what each message said, and how the answers were combined.
3:43So what this agent can do is set by its list. Adding an agent means adding its address.
3:48Its model will only know a new agent from its card, so a badly described card gets the wrong work.
3:53Handing work to several agents took a client for each card, and a model choosing between them.
3:59Each hand-off went through the same few lines, whoever built the agent.
4:02The decisions stayed in our program, including which agents get to see the user's question.
4:07Next time we look at what a delegation hands over, and what the protocol gives you to decide whom to trust.

One Agent, Many Agents

Created by Abhyuday DesaiPublished 4 Oct, v1 of 2Runs 4 min 13 sec

0 views

About this video

In Episode 10 of A2A Explained, a question needs two agents: how Apple did over the last month, with the price change in euros. Our analyst writes the brief, the currency agent another team built does the conversion, and a third program hands each one its part. That program is a client of both, with a model of its own, and it is sixty seven lines.

You'll learn how to:

Give one program a list of agent cards and a client for each
Offer each card to a model as a tool whose description comes from the card
Turn the model's tool call into a message to an agent, and its task's artifact back into the model's input
Read a real run where one agent's result becomes the next agent's request
Tell what the protocol makes uniform from what your program has to decide: which agent, what to send, how to combine

This video is for developers who know MCP's vocabulary. The code is in the series repo, pinned to the commit the video shows.

What changed

v204 Oct 2026abhydesai4 min 21 sec72b1b9c
Re-recorded with the closing attribution card, which the first cut left out, and with the spotlight back on scene six.

Same chapters. Transcript: 4 of 52 lines changed. 8 sec longer.
Show the differencesHide the differences
1. ~~The currency agent was built on LangGraph by another team, and our analyst is written in plain Python, with no framework.~~
  
  The two agents our program worked with were built by different teams.
  The currency agent is built on LangGraph, and our analyst is plain Python, with no framework.
2. ~~Everything else was our program's own logic: who got which part, what each message said, and how the answers were combined.~~
  
  Everything else was our program's own logic.
  It decided who got which part, what each message said, and how the answers were combined.
0 views0 likes on this version

Watch v2

v104 Oct 2026abhydesai4 min 13 secd8f4902

First published version.

0 views0 likes on this version