0:01Time to use all of this for real. On our side is a client, one Python file of thirty six lines, with no model of its own.
0:09On the other side is an agent we did not write. It is the A2A project's own currency converter sample, running on this machine.
0:16Our client reads its card, sends it one message, and prints the task that comes back. Let's look at the setup first.
0:24The code is public, and this video's folder holds the two programs side by side.
0:29The readme says what each one is and how to run them, the agent in one terminal and the client in another.
0:36The client needs one package.
0:38The A2A SDK for Python, pinned to the version everything in this series was captured with.
0:45And this is the agent. We treat it as a black box. It is the sample from the A2A project's own repository, copied here and run locally.
0:54One thing had to change to run it at our SDK version, and the readme says what. We never open its code, and we do not need to.
1:02Now our client.
1:05Here is the whole client. Thirty six lines, and no model anywhere in it.
1:09It does three things, in the order the last three videos taught them.
1:12The top is imports and a small helper. The work is one function, and the rest of the file fits on the screen.
1:19First it reads the agent's card. The SDK's resolver takes the address and fetches the card from the well-known path. No work has been sent.
1:27It prints the name, the description, and each skill, so we see what the agent said about itself.
1:32From the card it builds a client, with streaming off so one message gets one reply. Then it wraps our question as a message from the user.
1:40Then it sends it, and reads what comes back.
1:42Two things can come back. A direct message is printed as it is, and we are done.
1:47Or a task. Then we print its id and its state, anything the agent said on it, and every artifact with its content.
1:55That is the whole program. Let's run it.
1:58The agent is already running in another terminal, on port ten thousand.
2:02The client takes the agent's address and our request. We are asking how much a hundred US dollars is in euros.
2:08The card comes back straight away, and then we wait. The agent is working on the other side, and that took about nine seconds.
2:16What we have so far is what our client printed from the card. The agent's name, what it does, and its one skill, all read before we sent anything.
2:25Then the reply lands, and it is a task, not a direct message. It has an id of its own, and its state is completed.
2:31And the artifact, named conversion result, holding the answer. That is the deliverable, and it is all the client needs.
2:39Let's ask once more, and leave the currency out.
2:42Same client, same agent, and a request it cannot finish as it stands.
2:47The card comes back the same way, and then the same wait. The agent reads what we sent and decides what to do with it.
2:54So the task comes back stopped instead of finished. Its state is input required, and the agent's question is on the task. Answering on the same task is something we build in section two.
3:04The three ideas of this section are all in this one run. The card offered, in words, and our client sent one message.
3:11And the task carried the work back, with its state and the deliverable inside it. Nothing about how the agent did it crossed over.
3:20That closes the first section. Next time we start building.
3:24Our own agent, served behind a card of its own, small enough to read in one sitting.

Talk to Your First Agent

Created by Abhyuday DesaiPublished 2 Oct, v1 of 2Runs 3 min 29 sec

0 views

About this video

In Episode 04 of A2A Explained, first contact. Our own client, a plain program with no model of its own, fetches a card, sends one message and prints what comes back. The agent on the other end is the A2A project's currency sample, run locally as a black box.

You'll learn how to:

Write the client: fetch the card, send a message, read the task's state and its artifact, in about forty lines
Watch every named part from the first three episodes appear live: the card arriving, the task id, the state, the artifact's text
See what happens when a stranger's agent needs more: a task that stops in input-required
Close the first section with the idea complete and the build ahead

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 2026abhydesai3 min 34 secd7f62ff

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

Same chapters and transcript. 5 sec longer.

0 views0 likes on this version

Watch v2

v102 Oct 2026abhydesai3 min 29 sec484dddd

First published version.

0 views0 likes on this version