0:00Our client sends the analyst a question, and the analyst sends back a task that ends with a brief.
0:06Behind its card, the analyst is a model with one lookup. That lookup is a function in the analyst's own file, and it returns a stock's price history.
0:15A function that a model calls for outside information is what an MCP server offers as a tool.
0:21So that function can move into a server of its own. A server offers tools to whatever connects, and a client lists them and calls them.
0:29The analyst becomes that client. It asks the server which tools it has, and hands the list to its model.
0:35When the model wants prices, the analyst calls the tool on the server and passes the history back to the model.
0:41Our client still sends its question to the analyst, and to nothing else. Let's see what that looks like in the code, starting with the server.
0:49This is the analyst's folder, with two new files in it.
0:53This is the whole server, and it is a short file.
0:56It makes an MCP server and names it stocks.
0:58Then one function, registered as a tool. It is the analyst's price lookup, moved here as it was. A ticker and a period go in, and the daily closes come out.
1:09The last line runs it. Nothing in this file is about agents or tasks.
1:13Now the analyst, which has to use this server.
1:17This is the analyst as it has been, with the lookup written into it.
1:21This is the function we just saw in the server file.
1:24Under it is what the model is told about that function.
1:27We wrote this by hand. The tool's name, its arguments, and a reason the model has to give for each lookup.
1:34Both of those leave the analyst. Let's open the version without them.
1:39This is the new analyst. It is fifteen lines shorter, and the lookup function is not in it.
1:44In its place is the command that starts the server. Python, on the file we just read.
1:50The reason argument is kept on its own here, because the server's tool does not have one.
1:54Inside the function, the analyst opens a connection to the server. This line starts it as a child process, so there is nothing extra for us to run.
2:04Then it asks the server which tools it has, and builds the model's list from the answer. The name, the description and the arguments now come from the server.
2:13The one thing the analyst adds is that reason argument, so each lookup still says why it was made.
2:19The loop is the one we had. When the model asks for a lookup, this line sends the call to the server, where the old file ran the function itself.
2:27That is the whole change to the analyst. On the serving side, one word changes.
2:33This is the file that serves the analyst behind its card.
2:36This import is the only line we changed. It named the old analyst file, and now it names the new one.
2:42The card under it is the one we wrote, and nothing below it changed either.
2:46The analyst is already running in another terminal, started with the same command as before. This one is for the client.
2:53The client is the one we have used since our first agent. It fetches the card and sends one question.
2:58The card comes back at once. The rest takes about twelve seconds, so let's skip ahead.
3:02Meanwhile the analyst started its server and called the tool for Apple's prices.
3:06What the client printed first is the card. The name, the description and the skill are the ones we wrote. We compared the served card with the one from our first build, and not a byte differs.
3:20Then the task, completed, with the brief on it as an artifact.
3:24The brief describes Apple's month, from prices that came through the MCP server this time.
3:28That was the plain question. Let's ask a second one, with the client that streams.
3:34The second one is the comparison, which shows more of the analyst's work.
3:38The same month, with one more thing asked: whether Apple's move was only the market's.
3:43The real run took about eighteen seconds, so we are watching it sped up.
3:47First the task, submitted, and then working with nothing in it yet.
3:50Then two lookups, each with the model's reason. Apple first, and then a fund that tracks the broad market, for the comparison we asked about.
3:59Each of these is now a tool call to the MCP server. To the client it is what it was before, a status update on a task.
4:06The brief arrives as an artifact, with the comparison in it. Apple was up over the month, and the market was slightly down.
4:12And the task completes. Nothing the client printed shows where the prices came from.
4:17So the client's view is the same, and the analyst is now using a second protocol. Let's put both on one picture.
4:25The analyst has two connections now, and it is on a different side of each.
4:29To our client it is the remote agent. The client hands it a goal, and what the client knows about it is the description on its card.
4:36On the other connection the analyst is the one asking.
4:39With the server, the analyst is the client. Its model picks the tool and fills in the arguments, and the contract is the tool's schema.
4:47So this one agent uses both protocols, for different things.
4:50MCP is how it uses a capability, and agent to agent is how other agents hand it work.
4:56It works the other way round as well.
4:58An agent like ours can be offered to an MCP host as a single tool, and the host then calls it like any other.
5:05Everything we changed in this video was on the analyst's side of its card.
5:08Its lookup went behind a server, and the analyst became a client of that server.
5:13The card it serves did not change by a byte, and the two programs that talk to it were not edited. Each still got a task with a brief on it.
5:20Next time we start the last section. The analyst becomes one of two agents that a third one hands work to, on a question that needs both.

Where A2A Meets MCP

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

0 views

About this video

In Episode 09 of A2A Explained, the analyst's lookup leaves its own file and becomes a tool on an MCP server. The analyst starts that server, asks it which tools it has, and calls one when its model wants prices. On the agent to agent side, one word changes in one import, and the two clients we have been using get their briefs as before.

You'll learn how to:

Move an agent's own function behind an MCP server without touching what the agent serves
Build the model's tool list from what the server describes, and add an argument of your own to it
Check that the served card is unchanged, and that an unedited client still gets a completed task
Read each working update on the stream as what it now is inside the agent: a tool call to the server
Tell the two connections apart: an agent is delegated to by its description, a tool is called by its schema
Place the reverse direction, an agent offered to an MCP host as a single tool

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 2026abhydesai5 min 34 secre-render of the same sourcea216515

Re-recorded with the closing attribution card, which the first cut left out.

Same chapters and transcript. 6 sec longer.

0 views0 likes on this version

Watch v2

v104 Oct 2026abhydesai5 min 28 seca216515

First published version.

0 views0 likes on this version