0:01The first section was the idea. From here we build, and what we build now stays with us for the rest of the series.
0:07It is a stock analyst, and it belongs to us rather than to somebody else's project.
0:12Ask it about one stock over one period, and it fetches the price history it needs and writes a few sentences on what happened.
0:19And it is reachable at an address, behind a card that says what it can do, the way any agent on this protocol is. Let's look at the code.
0:30The folder holds three programs. The analyst, the server that puts it behind a card, and the client we already have.
0:38This is the analyst, and nothing in it speaks agent to agent. It is a model with one lookup.
0:44Everything it knows about its job is in one instruction at the top.
0:48Today's date, because a model has no clock. Fetch the price history you need. Fetch a second ticker only when the comparison earns a sentence. Write three to five sentences, and describe rather than advise.
1:01The lookup is the only thing it can reach for. Give it a ticker and a period, and it returns the daily closes.
1:07The rest of that function is formatting, so let's go on.
1:11That function is handed to the model as a tool, with one argument the model has to fill in beyond the ticker and the period. A reason, in a few words, for why it wants this lookup.
1:21And the last piece is the part that actually runs it.
1:24Then the loop. Ask the model, and if it answers, we are done.
1:27If instead it asks for a lookup, we report what it decided and why, run the lookup, hand the result back, and ask again.
1:36So the analyst chooses what to fetch and what to say. Now the part that puts it behind a card.
1:42This is the server, and it is the only file here that speaks agent to agent. Fifty four lines.
1:48Three parts, and we have met all three already.
1:50The card is written once, here, in the fields the protocol fixes. A name, a description, and what the agent takes and returns.
1:59Then the address where messages go, and the binding they are wrapped in. Ours is JSON-RPC over HTTP, on local host.
2:08And one skill, described in words rather than as a schema, with an example of the kind of question it answers.
2:15That is the card. The second part is what happens when a message arrives.
2:19The executor runs for every message that arrives. Its first move is to open a task and hand it straight back, so the caller has an id before any work starts.
2:29Then it marks the task working, and gives the analyst a way to report each lookup as a status message on that task.
2:35When the brief comes back it goes on as an artifact, named brief, and the task is complete. Opened, working, then finished with its deliverable inside it.
2:44And this is what serves it. The SDK builds the routes for the card and for the endpoint, and a web server runs them at the address the card claims.
2:53The card goes to the well-known path on its own. We never wrote that path down.
2:57That is the whole server. Let's start it.
2:60One command starts it, because the last four lines of that file are a web server.
3:04The packages and the model key are already in place, the way the readme sets them up.
3:10And it is up.
3:11Listening on the address the card claims. Anyone who fetches the well-known path on this host gets our card, and anything sent to the endpoint reaches the executor.
3:19It holds this terminal for as long as it runs, so let's talk to it from another one.
3:25We already have something that can talk to it. This is the same client we pointed at the currency agent, and it is not one line different.
3:33It still reads a card from whatever address we give it on the command line. Last time that was somebody else's agent. This time it is ours.
3:40The analyst is holding the other terminal, so this is a second one beside it.
3:45Our own address, and the question from the card's own example.
3:48The card comes back at once, and then we wait while the analyst works. About nine seconds, on this run.
3:54What the client printed is our own card, fetched from the well-known path. The name and the description we wrote, and the one skill.
4:01Then the task, completed, with an artifact on it called brief. Every name there came from the server file we just read.
4:08And this is the brief. It decided one lookup was enough, and it describes the month rather than advising us about it.
4:16The client knew two things about our analyst. An address, and what the card said.
4:20It never saw the model we chose, or what we told it, or the lookup it was given. We could change all three tomorrow and the client would not notice.
4:27One thing we did skip past, though. The task came back finished, so we never saw it working. Next time we ask a harder question and watch the task while it runs.

Build the Smallest A2A Agent

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

0 views

About this video

In Episode 05 of A2A Explained, the build begins, and what we build stays for the rest of the series. The analyst at its minimum is a model with a price-history lookup that knows nothing about A2A. The SDK's executor wraps it into a served agent whose card is already at its well-known address.

You'll learn how to:

Wrap a plain model-plus-tool program into a served agent with the SDK's executor
Find its card on localhost without writing it by hand
Repoint the client from Episode 04 at it by changing one thing, the address on the command line
State the deliverable once and keep it: a short brief about one ticker over one period
Hold the load-bearing line: the client needs nothing behind the card, not the model, not the prompt, not the lookup

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 42 sec1e3c6e1
The run was re-captured alongside episode six's, so the brief's figures come from the same day. Adds the attribution card at the end that the first version was missing.

Same chapters. Transcript: 1 of 43 lines changed. 5 sec longer.
Show the differencesHide the differences
1. ~~And this is the brief. It decided one lookup was enough, and it describes the month rather than advising us about it.~~
  
  And this is the brief. It looked only at Apple, and it describes the month rather than advising us about it.
0 views0 likes on this version

Watch v2

v102 Oct 2026abhydesai4 min 37 sec484dddd

First published version.

0 views0 likes on this version