0:01This is an agent loop. It sends a job to the model, runs whatever the model asks for, and feeds the result back.
0:09Then it does it again, until it finishes the task.
0:12That's the whole idea, and we'll build it ourselves in this video.
0:15Then we give the agent its first job: a new feature for md2html, the small Markdown-to-HTML tool it works on.
0:23There's one piece the loop needs that we haven't named yet: the tool. Tools get their own video, but the loop needs at least one. So which tool should we use?
0:35For this build, the tool is bash. That means the model can ask our program to run a shell command, the same kind of command we would type in a terminal.
0:44And because it's a shell, that one tool can do a lot: list files, search text, run scripts, run tests.
0:53And that's also the risk. The agent could do things outside of our project: delete files, change the wrong folder, or run programs we didn't want it to.
1:01Each command starts inside the sandbox, a throwaway copy of the project. But nothing stops the model from writing cd, or an absolute path.
1:11So on your own repositories, run it inside a Docker container, or on a machine you're willing to wipe.
1:16Later in the series, when we put this agent on the benchmark, every task runs in its own container.
1:22Now let's look at the code.
1:25This is agent.py. The whole agent is in this one file.
1:28This file has a lot of comments and docstrings. We will hide them, so we can focus on the code.
1:34The file has five parts, and this strip along the bottom follows them.
1:39First, the imports: the small handful of libraries the loop needs.
1:43These two paths are the project copy in initial, and the sandbox the agent works in.
1:49Then the model setup. This function picks the right API key from your env file, based on the provider.
1:55Then it builds the client we use to call the model. To switch providers, you change one line in your env file.
2:03Then our one tool: bash. It's a function that takes any command the model comes up with, as a string.
2:10Then we open a subprocess. That's how Python runs that bash command for us.
2:15And notice cwd equals SANDBOX. Every command starts inside that one throwaway sandbox folder.
2:23This try block is where the command actually runs, with a thirty second limit.
2:27If it hangs, the except path takes over: kill the command, and hand the model an error message instead, so it can adapt.
2:35The killing happens in this helper, _kill_process_tree. It's boilerplate cleanup, so we'll skip it.
2:41If it finishes, we tidy up the output: trim it, and cap it at fifty thousand characters so a chatty command can't flood the context.
2:50Then we note the exit code if it failed, and return it all to the model.
2:56This dictionary is the schema for the tool. The model never sees your Python code, only what you send it in the API request.
3:04So you have to describe the tool explicitly: its name, what it does, and the one argument it takes, a command.
3:11The model uses this to decide when to call the tool, and how to format its request so your code can parse it. That's the contract between your program and the model.
3:22Then we put that schema in the tools list, as our one and only tool. In the next video we add more, so this list will grow.
3:30Next, the system prompt: the standing instructions the agent carries into every task.
3:35The system prompt is set up in its own Markdown file. This one line reads it in. Let's open it.
3:44It's short, and most of it is about checking the work.
3:47It starts with the role. The agent is a coding assistant working on a project's code, and it carries the task through to the end.
3:54Then the biggest block, the verification rules. Like this first one: if the agent changed code, it must run the project's tests before its final answer.
4:04And if they fail, it fixes the problem and tests again.
4:09And a few rules on change hygiene: prefer the smallest edit, and clean up your scratch files.
4:15When the task is done, it stops using tools and sums up what it did. That reply ends the run.
4:21Take a few minutes to read this file yourself. Every rule in it was earned the hard way, on real-world repositories.
4:30Here's the main user task: the job we hand the agent to complete.
4:34It asks for a real feature in md2html: a table of contents. Every heading gets an id, and a marker line becomes a list of links to those headings.
4:44It points the agent at a pair of test files with the expected output, and asks for new tests with the old ones still passing.
4:54It's a short guide with a few headings, and the last two have the same text.
4:58This is the marker. The table of contents goes where it is, and the repeated headings need ids that differ.
5:06There's a little telemetry in the middle. This part records every tool call the agent makes, in order, so we can see the path it took.
5:15And this part records the token counts for the run. We'll come back to both of those numbers later.
5:22And now, the loop. The same loop from the opening scene, now in Python.
5:27It lives in one function, run_agent. And check the signature: a client, a model, a system prompt, tools, and a task.
5:35This function is self-contained. Import it anywhere, give it those five things, and it returns the final answer.
5:43Let's hide the lines for logging and metrics, so we can focus on the loop.
5:47First, we initialize the messages list. That's the conversation. It starts with just two entries: the system prompt, and the task.
5:55And then we enter the loop.
5:57We call the model with the whole conversation so far and our tools list, and it sends a response back.
6:03Then we look at that response, and add it to the conversation.
6:07When the model doesn't ask for any further tool calls, we're done, and the function returns the final answer.
6:14If the model asked to run a tool, we run each call. We also print the command and the start of its output, which is what we'll watch in the terminal.
6:23And then we append the result back into the messages list. That one line is what makes this a loop, rather than a one-shot call.
6:32On its next turn, the model sees the tool output in the conversation, so it knows what happened and what to do next.
6:40So that's the entire loop. There's one question left: who calls this function? Let's look at that next.
6:48At the bottom of the script, we have the main function.
6:51This is the entry point.
6:52First, the sandbox reset: every run clears out the sandbox and copies initial into it, so the agent starts fresh.
6:59Then the agent is supposed to do all its work inside sandbox.
7:03Then the model setup: we read the env file, pick the model, and build the client, with the make_client function we saw earlier.
7:11Then we hand everything to run_agent. This one line runs the whole agent.
7:16And when it comes back, we print the final answer and write the bookkeeping files: the tool calls, and the metrics.
7:23So that's our agent, the whole machine in one file.
7:26Take your time to go through this script. This simple loop is the mechanism that drives every coding agent.
7:32Now let's run it.
7:34We already made the virtual environment and installed everything, so we can just run it.
7:38To run it, we go through the harness, run.py, with the --capture flag, so the whole run will get saved.
7:48Okay, it's running now. We're using the GLM 5.2 model, set in the env file. This will take a few minutes, so we'll cut to the end.
7:58It's done. Let's check what it says.
8:01This is the summary the agent gave us. It added a new extension that hooks into each stage of md2html, from reading the Markdown to writing the HTML.
8:11Because every heading now gets an id, the expected output of two older fixtures changed, and it updated both.
8:19It added tests of its own and a line in the README, and ran the whole suite. All sixty-one tests pass.
8:26These tests are in the sandbox, so the agent can edit them. Updating the two older fixtures was right, but an agent could also change a test just to make it pass.
8:40Our system prompt has a rule about this.
8:42The agent should change an existing test only when the task needs that change.
8:47That's an instruction, though, not a guarantee. We'll come back to this through the series, and the verification video covers it in detail.
8:56Remember the --capture flag? Everything this run did got saved.
9:02There's a new run folder in the logs, stamped with the time.
9:06And inside are the full terminal log, every tool call, and the token numbers.
9:11These files tell us how the agent went about the task. Let's look at what the run cost, and then at the path it took.
9:20Here's the bill for this run. The model was called thirty-three times, and it made thirty-two bash calls.
9:25Almost nine hundred thousand tokens went in, and about seventeen thousand came out.
9:30With every call, we send the whole history so far, and the history grows with each turn, so the input tokens add up fast.
9:38And the whole run took about two and a half minutes.
9:42Here are all thirty-two calls, in the order the model made them.
9:45It starts by reading: the fixture it has to match, the existing extensions, the parser and renderer, the tests, and the README.
9:54Before it changed anything, it ran the tests, and the table of contents fixture failed, as the task said it would.
10:01Then it wrote the whole extension file with a single shell command.
10:05To register it, it wrote a short Python script to the system's temporary folder, outside the sandbox. Nothing in our code stops that, which is why you run an agent like this in a container.
10:17Then two older fixtures failed, because every heading now gets an id. It rewrote both expected files and ran the tests again.
10:25Next it wrote its own tests, ran them, fixed one, and ran the whole suite.
10:30Near the end, it updated the README, checked the command line, and deleted its temporary files, as the system prompt asks. Its last calls check which files it changed.
10:40The tests run seven times, spread through the run, so each change is checked before the next one.
10:46Put together, the run moves back and forth between reading, changing files and testing, one call at a time.
10:53That's the whole agent for this video.
10:56The loop worked, even with one blunt tool. It added a real feature to md2html.
11:02So the next video is tools. Not a new loop, just better tools for the same one. I'll see you there.

The Loop

Created by Abhyuday DesaiPublished 5 Oct, v1 of 4Runs 11 min 16 sec

1 view

About this video

The first build of Building AI Agents. The loop is a while loop: the task and the system prompt go to the model, our code runs whatever tool the model asks for, adds the result to the conversation and sends it back. When the model replies without asking for a tool, that reply is the answer. The whole agent is one file, agent.py, and we walk it part by part.

You'll see:

The one tool the loop needs: bash, how much a single shell command can do, and why you run an agent like this in a container
agent.py in five parts: the setup, the bash tool, the prompt and the task, run_agent, and main
The bash tool: a subprocess in the sandbox, a thirty-second limit, trimmed output, and the schema the model actually sees
The system prompt: the verification rules the agent carries into every task, and the change hygiene it asks for
run_agent: the conversation list, the call to the model, running the tool calls, and the condition that ends the loop
A real run on GLM 5.2: the table-of-contents feature the agent added to md2html, the token bill, and all thirty-two tool calls in the order it made them
The finished feature on a real document: the agent's md2html renders a contributor guide to a page, with a nested table of contents whose links jump to their sections

The next video replaces the one bash tool with proper tools for working with files.

What changed

v406 Oct 2026abhydesai12 min 39 secbe9e224

Pacing improvements through the walk of agent.py and the ending. The narration is unchanged.

Same chapters and transcript.

0 views0 likes on this version

Watch v4

v306 Oct 2026abhydesai12 min 37 sec17b5f24
The video now ends by showing the feature actually work. The agent's md2html renders a real contributor guide to a page, and the page opens with a nested table of contents whose links jump to their sections. It closes on what the agent did unaided: found its way around a codebase it had never seen, wrote the extension, updated the two fixtures the change affected, and tested the result. With the payoff carrying that, the sign-off is now short: the agent works, and the next video gives it better tools. The code is shown at a newer commit, wrapped to 86 columns, with render.py and the sample document in the tree. Narration and pacing polish: a number of lines reworded for tone and clarity, and the walk through agent.py now moves between definitions by the file's outline.

Chapters: one added. Transcript: 21 of 102 lines changed. 30 sec longer.
Show the differencesHide the differences

Chapter added
The page
1. ~~So on your own repositories, run it inside a Docker container, or on a machine you're willing to wipe.~~
  
  So with your own repositories, run it inside a Docker container or a virtual machine, kept apart from the rest of your computer.
2. ~~Here's the main user task: the job we hand the agent to complete.~~
  
  Okay, that was our system prompt. Now here's the main user task: the job we hand the agent to complete.
3. ~~Here's the task. It asks for a real feature in md2html: a table of contents. Every heading gets an id, and a marker line becomes a list of links to those headings.~~
  
  Here's the task. It asks for a real feature in md2html: a table of contents. Every heading gets an ID, and a marker line becomes a list of links to those headings.
4. ~~Because every heading now gets an id, the expected output of two older fixtures changed, and it updated both.~~
  
  Because every heading now gets an ID, the expected output of two older fixtures changed, and it updated both.
5. ~~Then two older fixtures failed, because every heading now gets an id. It rewrote both expected files and ran the tests again.~~
  
  Then two older fixtures failed, because every heading now gets an ID. It rewrote both expected files and ran the tests again.
6. ~~That's the whole agent for this video.~~
  ~~The loop worked, even with one blunt tool. It added a real feature to md2html.~~
  ~~So the next video is tools. We keep the same loop and give it better tools. I'll see you there.~~
  
  Now let's try the table of contents on a real document.
  This is a short contributor guide, written in Markdown, with headings at three levels.
  This marker near the top is where the table of contents should go.
  So we expect a nested list of links to these headings.
  Let's render it with the agent's version of md2html.
  This runs md2html from the agent's sandbox on our guide, and writes the page next to it.
  The new page is in the examples folder. Let's open it.
  At the top is the table of contents, nested the same way as the headings.
  Each link jumps to its section, through the ID its heading was given.
  Our agent built all of this on its own.
  It found its way around a codebase it had never seen.
  It wrote the extension, and updated the two fixtures the change affected.
  And it tested its work: it added tests, ran the whole suite, and all sixty-one pass.
  So now, we have a working agent.
  In the next video, we give our agent better tools so it can carry out harder tasks.
  I'll see you there.
0 views0 likes on this version

Watch v3
v206 Oct 2026abhydesai12 min 7 sec424bd83
Restructured so the task is explained right before the run, not three scenes earlier. A new bookkeeping scene points at the task, defers it and covers the telemetry; the task scene itself now sits after main and ends by starting the run; the run scene reviews the finished output. Thirteen scenes became fifteen, renumbered to match the order. Cut: the walk through the sample Markdown file - its headings, the marker line and the repeated headings - since the task box already states what it showed. Added: main now says the agent works on a copy, so the original project never changes; and a silent "Try it yourself" card closes the video. Narration: the test files are named as fixtures where the task first points at them, the close drops its "Not a new loop, just better tools for the same one" fragment for a plain line, and over-long sentences are split. Visuals and timing: the terminal runs are re-transcribed on the capture's own clock at 1x, visible clicks keep their click sound, scroll targets land clear of the top border, the big terminal boxes scroll to fit whole, the bill carries a note that your own run will differ, and the Popen box covers the whole call.

Chapters: two renamed, one added. Transcript: 12 of 102 lines changed. 51 sec longer.
Show the differencesHide the differences

Chapter renamed
~~The task~~ The task, for later, and the telemetry
Chapter renamed
~~The run~~ The task and the run

Chapter added
The run's result
1. ~~It asks for a real feature in md2html: a table of contents. Every heading gets an id, and a marker line becomes a list of links to those headings.~~
  ~~It points the agent at a pair of test files with the expected output, and asks for new tests with the old ones still passing.~~
  ~~It's a short guide with a few headings, and the last two have the same text.~~
  ~~This is the marker. The table of contents goes where it is, and the repeated headings need ids that differ.~~
  
  We'll come back to it just before we run the agent. For now, let's continue with the rest of the script.
2. ~~And now, the loop. The same loop from the opening scene, now in Python.~~
  
  And now, the loop. The same loop from the start of this video, now in Python.
3. ~~And then we append the result back into the messages list. That one line is what makes this a loop, rather than a one-shot call.~~
  
  And then we append the result back into the messages list.
  That one line is what makes this a loop, rather than a one-shot call.
4. ~~Then the agent is supposed to do all its work inside sandbox.~~
  
  The agent works on this copy, so the original project never changes, and all its work is meant to stay in the sandbox.
5. ~~Now let's run it.~~
  
  Before we run it, let's look at the task we'll give it.
  Here's the task. It asks for a real feature in md2html: a table of contents. Every heading gets an id, and a marker line becomes a list of links to those headings.
  It points the agent at a pair of test files, called fixtures, with the expected output. It also asks for new tests, with the old ones still passing.
6. ~~So the next video is tools. Not a new loop, just better tools for the same one. I'll see you there.~~
  
  So the next video is tools. We keep the same loop and give it better tools. I'll see you there.
0 views0 likes on this version

Watch v2
v105 Oct 2026abhydesai11 min 16 secfe885a1

First published cut

1 view1 like on this version