The Tool Is an LLM Application
Tessa is standing behind Milo's chair while he builds the review-trends page, and something on the screen is bothering her.
He typed one sentence describing what he wanted. Since then the tool has changed two files, started the page, hit an error, read the error, changed one of the files again, and started the page again — and Milo has not touched the keyboard. He is drinking his coffee.
"What is that thing?" she asks. "What is actually happening while it does that?"
It is the last question of the chapter, and it closes the circle this book has been drawing since page one. Because the answer is: it is the model she has been reading about all along — the same provider, the same request, the same payload from Chapter 7 — wrapped in a loop that a program runs. She has met every part. She has even commissioned one, in Chapter 8, with herself standing in for the loop.
The Anatomy, in Her Vocabulary
No comparison to a kitchen, a post office or a filing cabinet on this page. For eight chapters the machinery needed everyday pictures to get into your head; it does not need them any more, and this is the first page of the book that describes a machine entirely in the book's own terms. That is not a stylistic choice. It is the graduation.
So, in her vocabulary, four parts.
A system prompt. Standing instructions, exactly as Chapter 8 described them: you are a coding assistant working in this project, here is how it is laid out, always run the tests before saying you are done, never touch these files. Written once by whoever built the tool, sent with every request.
The task, as a user message. Milo's one sentence, dropped into the same slot Tessa's questions have always gone into.
A reply that contains something to do. This is the part worth slowing down for. The model's answer is not only prose for a human to read. Some of it is a specific, structured statement of an action: open this file, replace these lines, run this. It is text — it was always going to be text, the machine has no other output — but it is text in a shape the surrounding program knows how to act on, the way Chapter 5's labelled data was text in a shape a program could unpack.
The outcome, sent back as the next message. The program performs the action and takes whatever came out — the file changed, the error message the computer printed, the test that failed — and adds it to the conversation as the next message. Then it sends the whole thing again, exactly as Chapter 7 said every chat box has always done: the history re-sent, one turn longer each time.
And then round again, until the model's reply says the work is done, or the loop hits a limit somebody set on how many rounds it may take.
Read that list back and count the parts. Not one of them is new. System prompt, user message, a reply, and the outcome added to a history that is re-sent one request at a time — every one of those is a page you have already read, arranged in a circle instead of a straight line.
The One Thing That Is New
The parts are all old. What is done with one of them is not, and it is worth stating on its own.
The model's reply drives a program's next step. Not a human's next step — a program's. Nobody reads the reply, decides what it means, and copies something into a terminal. The program does the deciding-free part automatically: it takes the action out of the reply, performs it on real files and real commands, and feeds the result back in.
That is what the word agentic means, and it is the entire difference between this and everything else in the book. The chat box answers. This acts.
It is also the whole explanation for the thing Tessa noticed. The tool works unattended for minutes at a time because nothing in the circle needs a human: each round produces an action, the action produces an outcome, and the outcome is the next round's input. Milo's coffee is not evidence of intelligence. It is evidence that the loop no longer passes through him.
Compare it with Chapter 8's twenty lines and the shape gets very clear. That program also sent requests in a loop, 2,300 of them. But it decided in advance what every request would be, and the model's answers went into a file. Here the model's answers decide what happens next. That is the step.
Why That Step Changes the Stakes
A loop that acts needs things an answering chat box never did, and Tessa gets to all three within about a minute of thinking about it.
It needs limits. Which files may it change, which commands may it run, what is it forbidden to touch. A wrong answer in a chat box is a sentence you delete. A wrong action is a file that is now different.
It needs a check before anything irreversible. Some actions can be undone and some cannot, and the ones that cannot — deleting things, sending things, spending money — are the ones where a loop running unattended is a different proposition from a loop that pauses and asks.
And it needs a human somewhere in the circle. Which is a sentence the reader has already seen, one page ago, in different words. Milo reading every change before he keeps it is that human. The last page presented review as good craft; this page shows what it is structurally: the point where a loop that acts on the world reconnects to somebody accountable for what it did.
Tessa can feel the next questions arriving as she asks these ones. What limits, exactly? Decided by whom, and enforced how? What counts as irreversible? How would anyone test a thing whose whole job is to act differently every time?
Those are good questions, and this book stops here on purpose.
Where This Book Stops
What this book owns is the floor: what the model is, how to ask it well, when not to believe it, what goes in and what must not, the request on the wire, the key, the errors, the bill, and the product built on top. That floor is what makes the loop legible at all — and legible is exactly what it was, when Milo explained it, to a marketing coordinator who writes no code.
What it does not own is how to build one. The tools such a loop may call and how they are described to the model, the context it carries and what it drops, the guardrails and who sets them, how you evaluate a thing that acts rather than answers, what happens when several loops run at once — that is not an appendix. It is a book, and it exists: Agentic AI from Scratch, the next course on this shelf, aimed at the reader who has finished this page. Its entry bar is a working understanding of the request, the payload and the status codes, plus enough to read a small program and enough to say what a model does — which is Chapters 7 and 8 and the first chapter of all, and you have read them.
So the ladder stands. Machine Learning from Zero is how these models are made. This book is how to work with them. Agentic AI from Scratch is how to build around them. Chapter 11 draws that map properly, and there are two chapters left before it — because there is one more thing this book owes you before it starts pointing at other books, and it is the honest one: when not to use an LLM at all.
- "Agentic tools are a new kind of AI." Same model, same requests, same payload. The novelty is the loop built around it — a program that acts on the replies instead of showing them to you. The wrapper from Chapter 7, evolved.
- "It runs on its own, so it is autonomous." It runs until the work is done or it is stuck, inside limits somebody chose, and its output still meets a human who reads it. Those limits and that reading are load-bearing parts of the machine, not decoration on it.
- "So this book taught me agents after all." It taught the floor underneath them — the call, the wire, the payload, the trust doctrine. The engineering of the loop itself is the next book, and knowing exactly where that boundary sits is part of knowing either subject.
- "The model is running the commands." The model produces text describing an action. The program around it decides whether that action is permitted and then performs it. Everything the loop is allowed to do was allowed by somebody who is not the model.
- The reader now knows exactly what an agentic tool is made of — and exactly what they do not yet know about building one. That is the healthiest possible state to begin a deep dive from, and the least likely to be impressed by a demonstration.
- It is also the moment the book's method pays off. A machine that sounds like magic in a vendor pitch turned out to be four familiar parts in a circle, and the reader could take it apart because they had read every part separately.
Knowledge Check
In this book's terms, what is an agentic coding tool made of?
- The same request and payload, wrapped in a loop
- A model retrained on the project it is working in
- Several models checking each other's work in turn
- A library of stored programs the tool selects from
Which single step is genuinely new, compared with everything earlier in the book?
- The whole conversation is re-sent on each turn
- A program acts on the reply without a human in between
- The request carries standing instructions with it
- Many requests are sent one after another
Why does acting raise the stakes compared with answering?
- Each round of the loop costs considerably more to run
- The model makes more mistakes when it works unattended
- A wrong answer is deleted, but a wrong action has happened
- More of the company's private material reaches the provider
What does this book hand over to Agentic AI from Scratch?
- How models are built and trained in the first place
- Building the loop: its tools, context, limits and evaluation
- Reading requests, payloads and status codes as they travel the wire
- Deciding which tasks an LLM should not be used for
You got correct