0:01In the last video, we built this agent loop with one tool, bash. It read the files, wrote them, and ran the tests.
0:09This video gives the agent a new task.
0:11It's a new feature for md2html: GitHub's emoji shortcodes, where a name between two colons becomes an emoji.
0:19To support every one of them, the agent needs GitHub's own list of shortcodes, and that list is published on the web.
0:26So in this video our loop stays the same.
0:29But now we give our agent better tools. So which tools do we give our coding agent?
0:35We keep bash, and we add seven more tools.
0:38First, list files. With it, the agent can see every file in a project in one call, without git or cache folders.
0:45Second, read. The agent can use this tool to pull up any file's contents, with line numbers.
0:51The third tool we're adding is grep. It's useful to search the whole codebase for a pattern.
0:56Bash can run grep too. This one skips cache folders, like list files does.
1:01And it stops at fifty matches, so the agent's context doesn't fill up.
1:06Next, the write tool. Now the agent can create or overwrite a file in one shot.
1:11Then edit. Use this tool to change one part of a file, without rewriting the whole thing.
1:17And the last two are for the web: one searches, and the other downloads what it finds.
1:21That's seven new tools, eight with bash, the agent's entire action space.
1:27Before the code, let's understand how the model learns about a tool.
1:31Take the write tool as an example. In code, it's a plain Python function: it takes a path and some content, and writes the file.
1:39Now we need to tell the model about this capability. The model needs a structured definition for the tool.
1:45It has a name, a description, and the arguments it accepts. This schema is what the model actually reads.
1:52Why do we need this schema and this structure at all?
1:55Fair question. The function here is short, but tools can get lengthy, even hundreds of lines of code. So we would bloat the context.
2:04The model only needs to know what the tool is for, what it takes, and what it returns. A schema covers exactly that.
2:11Writing that schema by hand for every tool gets repetitive and laborious. Imagine doing this for ten, or twenty tools.
2:19So we add a helpful utility to make our job easier, a tool decorator.
2:23Here's how it works. You give it a description string, it reads the function's signature, and attaches the schema right onto the function.
2:32The main thing to remember is the why. Each tool needs a schema, but we don't want to write it by hand, so we use the tool decorator to write it for us.
2:41If that feels like a lot, don't worry. We'll go through all of it in the code now.
2:49This video's code is in the tools folder, and there's a new file in here, tools.py.
2:56It's a fair bit of code. First, let's hide the comments and docstrings, to cut the noise.
3:01We'll also close the file tree, to give the code more room.
3:06Let's bring up our build map for tools.
3:08We will start with the tool definitions.
3:11You can see the tools are here. We have already seen bash in the last video.
3:16Now we will look at four of the new tools: write, list files, and the two web tools.
3:22Let's start with write, our example from earlier in this video.
3:27Given a path and the content, it writes the content to that file. One line here is worth stopping on.
3:34Safe path: every write starts by running the path through it. Let's go and see what it does.
3:41The whole purpose of this function is to keep the writes contained in our sandbox folder.
3:46If the path tries to escape the sandbox, this line raises an error. So we don't allow our agent to write any files outside the sandbox.
3:55And this safe path check is not just for write. We do the same in the other tools as well.
4:01Next, let's check the list files tool.
4:04This tool's job is to return the list of files given a path.
4:07It starts the same way, with safe path again, so you can only list what's inside the sandbox.
4:13After that, it just walks the folder tree at the given path, and collects every file it finds, skipping caches and version control folders.
4:22We are capping the list at two hundred files. Why? If a repo has thousands of files, dumping names of all of them would bloat that context, for almost no benefit.
4:33So the cap on files returned is a way to manage context.
4:37Now let's look at the two web tools.
4:40Web search sends a query to a search engine and returns the top few results. Each one has a title, a link and a short snippet.
4:50Fetch URL downloads whatever is at the address. If the download fails, the error comes back as text the model can read.
4:58With save to, the whole download is written to a file in the sandbox, through the same safe path check. Only its size and the first five hundred characters come back to the model.
5:09Without it, the text itself comes back, cut at fifty thousand characters.
5:13So two habits run through these tools: first, keep the agent sandboxed, and second, keep what it returns lean.
5:21Okay, that's the tools themselves. Now let's check the tool decorator that generates the schemas.
5:28This decorator is boilerplate code, so don't worry too much if it looks a bit obscure. Typically you can just copy and paste it from one agent project to another.
5:38At the top, it takes the plain-English description we want to give the model. And it holds the mapping from Python types to schema types.
5:47Then it reads the function's signature, the argument names and their types, and turns them into the list of parameters.
5:54And then it assembles the whole thing into the form the model expects: the name, the description, and the parameters, straight from the function.
6:05And notice this line. It attaches all of that onto the function itself, as a tool definition attribute. Make a note of it, we'll come back to it in a moment.
6:18So that's it for our decorator. And now, all we need to do is put it on top of our tool signatures. For example, let's look at the bash tool.
6:27This line here takes care of the schema generation for us. No hand-writing of schemas is needed anymore.
6:34Our tools are now set up, along with their schemas. Next, we bring them to our agent.
6:39For that, we have a tool registry at the bottom of this script.
6:45It's a list of all our tools, and it's what the agent gets.
6:48Now let's open agent.py, where we have the agent loop.
6:55Let's check what's changed here.
6:57Right at the top, we make the imports from the tools script we just saw.
7:01Our next change is in the agent loop.
7:05The loop starts by building two things from the tools: a lookup from each name to its function, and tool defs, the list of schemas.
7:12Remember that tool definition attribute from the decorator? We pull it off every tool to build this list.
7:20This part here, every time around, we send the whole conversation to the model, and along with it, the tools.
7:29When the model asks to use a tool, we look it up by name. This is the one real change from the last video.
7:36Then we read out the arguments it wants, parsing them right here.
7:40And we call it, with those arguments.
7:44If a tool raises an error, like the sandbox check, the error goes back to the model as the result, so it can correct itself.
7:52Then the result goes straight back into the conversation, and the loop runs again.
7:58So those are the updates. Not a lot of change here.
8:01Now we can test this out on this video's task.
8:04Before we run it, let's remember what we're asking the agent to do.
8:09We want md2html to turn GitHub's emoji shortcodes into emoji, for every shortcode on GitHub's list.
8:16And the list has to be stored in the repository, so it works offline. That means the agent has to get the list from the web first.
8:24Now with better tools, let's see how our agent performs on the task.
8:29Same command as before, just pointing to this video's code.
8:35Okay, our agent is going at it. This runs for a little while, so let's skip ahead to the end.
8:42And it's done.
8:44At the end, the run prints how many model calls it made and the tokens it used.
8:49We'll look at these numbers more closely in a bit, but first, let's see what the agent says it did.
8:55This is the summary the agent gave us. It saved GitHub's whole list in the project, generated from GitHub's own gemoji data.
9:03Then it added the extension itself. It looks up each shortcode it finds and leaves unknown ones as typed.
9:12The fixture now matches, and all seventy tests pass, including the twenty-seven it wrote.
9:18Now let's look at these numbers more closely.
9:22Here's the bill for this run. The model was called forty-four times, and it made forty-three tool calls.
9:30About nine hundred and forty thousand tokens went in, and about nine thousand came out.
9:34GitHub's list isn't in that number, because it was saved to disk instead.
9:39And the whole run took just under two minutes.
9:42Here are all forty-three calls, in the order the model made them.
9:46It starts by reading: the extensions, the parser and renderer, the fixture it has to match, and the tests, all through list files and read.
9:55Then it went for GitHub's list, at an address it already knew, so it didn't need a web search.
10:01Its first fetch asked to save the file in the system's temporary folder. The sandbox check refused it, and the error went back to the model.
10:09So it asked again, with a path inside the sandbox, and only the size and the first lines came back.
10:15Then it ran short Python scripts to turn the list into the data file the task asked for.
10:21It wrote the extension in one call, and registered it with two edits. A third edit ships the data file with the package.
10:28Then it ran the tests, checked the fixture by hand, wrote tests of its own, and ran the suite.
10:34At the end, it tried the command line, deleted the raw download, and checked which files it changed.
10:41Now let's use the emoji extension on a real document.
10:45These are short release notes, written in Markdown, with emoji shortcodes between colons.
10:52We expect each of these shortcodes to become its emoji, including the plus one at the end, which is GitHub's other name for thumbs up.
10:60And the one inside inline code should be left exactly as written.
11:04Let's turn it into a page with the md2html the agent just changed.
11:09The script takes the copy in this video's sandbox, so we get the agent's version, not the original.
11:16And here's the page it wrote, beside the notes. Let's open it.
11:22Every shortcode became its emoji, and the one in inline code was left as written.
11:27Our agent did all of this on its own, and this time it used the web.
11:31It downloaded GitHub's own list of shortcodes and saved it in the project.
11:36It turned that list into a data file, and wrote the extension that uses it.
11:41Then it checked its work: all seventy tests pass, twenty-seven of them its own.
11:48Those are the basics of tools. They do two kinds of jobs.
11:52Most of ours bring context to the model: reading files, and getting information from the web.
11:58The rest take action, like writing and editing files.
12:01And you can extend this idea to whatever your agent needs. For context, a tool could run a vector search over a knowledge base, finding passages by meaning, not exact words.
12:13Or it could pull records from a database.
12:16For action, a tool could send an email.
12:18Or it could update a record in another system.
12:22Tools like these can make an agent very capable. So think about what you give it, and give it only what a task needs.
12:29That's tools: how an agent brings in context and takes action.
12:33In the next video, our agent learns skills: instructions it can load on demand.
12:38I'll see you there.

Tools

Created by Abhyuday DesaiUpdated 6 Oct, v2Runs 12 min 51 sec

1 view

About this video

The second build of Building AI Agents, and this one is about tools from end to end. The last video gave the agent a single bash tool only because a loop needs at least one to run; here tools are the subject. The loop itself does not change at all. Everything the agent gains comes from what you hand it and how you describe it. The task makes that concrete: md2html has to turn GitHub's emoji shortcodes into emoji, GitHub's full list lives on the web, and bash alone cannot reach it.

You'll see:

What a tool is to a model: a name, a description and its arguments, and why the model reads that schema instead of your Python
The decorator that generates the schema from a function's own signature and attaches it to the function, so defining a new tool is writing one plain function
What a tool has to guard: safe path, which keeps every read and write inside the sandbox, and the caps that stop one call from filling the context
How tools reach the model: the registry, the name-to-function lookup, the list of schemas, and the tools going along on every turn
The eight tools this agent ends up with, and the two jobs tools do: bringing in context, and taking action
A real run where the sandbox check refuses a fetch, the agent adapts, and the feature ends up working offline
How far the idea extends: a vector search over a knowledge base, records from a database, sending mail, updating another system, and why you give an agent only what a task needs

The next video gives the agent skills: instructions it loads only when a task needs them.

What changed

v206 Oct 2026abhydesai12 min 51 secbe9e224
The write tool is now explained where its code is opened. The previous version skipped it as already seen, which left the one tool the schema section used as its example never walked through. The video now also says why grep is worth its own tool when bash can already run grep: it skips cache folders and stops at fifty matches, so the model's context does not fill up. Other changes are pacing.

Same chapters. Transcript: 2 of 127 lines changed. 5 sec longer.
Show the differencesHide the differences
1. ~~Let's start with write, because we were just looking at it.~~
  ~~You have seen this one already, so we won't explain it again. But there's one line worth stopping on.~~
  
  Let's start with write, our example from earlier in this video.
  Given a path and the content, it writes the content to that file. One line here is worth stopping on.
0 views0 likes on this version

v106 Oct 2026abhydesai12 min 46 sec1c0d77e

First published cut

1 view1 like on this version

Watch v1