0:00Our analyst is built and serving behind its card, and we have a client that can ask it for a brief.
0:05Today we ask it something that takes longer, and we stay with the task while it works.
0:10Our client blocked until the finished brief came back, so the work in between was never on screen.
0:16So we follow one task twice. Once watching only what its state says, then again with every update the agent sends as it goes. Let's take the states first.
0:30This is the client that asks again. It sends the same question, then keeps checking on the task it gets back.
0:35The send is set to come back as soon as the task exists. So what we get is an id and a state, not a finished brief.
0:43Then the loop. Once a second it asks for the task again, and prints the state only when it changes. It stops when the task reaches a state it cannot leave on its own.
0:53The analyst is still serving in the other terminal. This one is ours.
0:57Here is the question, and this time it asks whether the month was really about Apple.
1:01The task comes straight back, submitted. The agent has it and has not started.
1:06A second later, working. That is the agent saying it has begun.
1:10For the next eleven seconds every answer is that same word. The loop asks again each second and prints nothing new.
1:17Then completed, with an artifact on the task called brief.
1:21Apple gained one point seven percent while the broad market was flat, so the month was Apple's own, not the market's.
1:27The states told us when the work began and ended, nothing more. That the analyst fetched the market too only shows up in the brief.
1:34The streaming call shows that while it happens.
1:38This is the other client. The same question goes out, and one call is different.
1:43It passes its own HTTP client with a long timeout. The default gives up after five seconds of quiet, and the analyst takes twelve.
1:51This send streams, because the card says the agent can. Every event the agent publishes arrives here as it happens.
1:58Three kinds come through. The task, a status update that may carry a message, and an artifact when a deliverable is ready.
2:05Our terminal still holds the polled run, so let's wipe it first.
2:10This is word for word the question we asked a minute ago.
2:13The task arrives first, submitted, and a working status right behind it with nothing in it yet.
2:18Those two are the states we polled for, and this time nobody had to ask for them.
2:23This is the part the states never carried. Two lookups, each with the reason the model gave for it.
2:28The second one is the comparison. The analyst's instructions allow a second ticker when the comparison earns a sentence. It asked for both at once, before either answer came back.
2:38Then the brief arrives, as an artifact event of its own.
2:41The completed status comes after it, so the brief was in hand before the task closed.
2:46Same twelve seconds, and this time the agent said what it was doing while it did it. The two runs cost the server very different amounts of traffic.
2:55Both of those runs went over this one connection.
2:57The polled run sent the question, and the task came straight back with its id.
3:01That is one round trip.
3:03Then, once a second, it asked for that task again until the state changed.
3:07By the time the brief was ready that was twelve more requests, and ten of them learned nothing new.
3:12The streaming run sent the question once, and the agent pushed each update back as it happened.
3:17Six events on one request, and they carried the reasons the states never did.
3:21There is a third way, and it does not use this connection at all. We can register an address of our own with the agent.
3:27Then the agent calls us when something happens.
3:30One request from us, and after that nothing of ours has to sit and wait.
3:33Every update is delivered to that address. That is a push notification, and the final video builds one.
3:40What came back from the analyst was not a finished answer. It was work in progress, and we could watch it move.
3:46Because it has an id, we could ask for it again. Because the agent publishes as it goes, we could listen instead. The protocol is built around work that takes time.
3:56This one ran straight through, though. Next time the analyst needs something from us before it can finish, and the task stops in the middle to ask.

A Task Is Not a Return Value

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

0 views

About this video

In Episode 06 of A2A Explained, the analyst is asked whether Apple's month was just the market, and the work takes more than ten seconds. Nothing behind the card changes. What changes is what the client can see while the task runs: its states if it asks again, and the agent's own notes if it subscribes to the stream.

You'll learn how to:

Send a message and get the task back as soon as it exists, instead of waiting for the result
Ask for a task again until it reaches a state it cannot leave
Switch to the streaming send and read the task, its working updates, its artifact, and its final status as they arrive
See what each view costs: one send and twelve asks, against one request carrying six events
Know the third way a task's end can reach you, a webhook you registered, which the last episode builds

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 14 sec1e3c6e1
Both runs re-captured on the same day, so the figures in episodes five and six now come from one sitting; the note about the two capture dates is gone. Adds the attribution card at the end that the first version was missing.

Same chapters. Transcript: 2 of 43 lines changed. 7 sec longer.
Show the differencesHide the differences
1. ~~It passes its own HTTP client with a long timeout. The default gives up after five seconds of quiet, and the analyst takes twelve.~~
  
  It passes its own HTTP client with a long timeout. The default gives up after five seconds of quiet, and the analyst can be quiet for longer.
2. ~~Same twelve seconds, and this time the agent said what it was doing while it did it. The two runs cost the server very different amounts of traffic.~~
  
  The same question, and this time the agent said what it was doing while it did it. The two runs cost the server very different amounts of traffic.
0 views0 likes on this version

Watch v2

v104 Oct 2026abhydesai4 min 7 sece90fbe6

First published cut

0 views0 likes on this version