Under the Hood · Part 6 · 5 min read · The finale
The destination, not the route
You don't hand an agent the steps. You hand it a goal — and let the world correct it.
By Aikansh ·
Punch an address into your car's GPS and it doesn't read you a fixed list of turns and wish you luck. It starts you moving, watches where you actually are, and the second you miss an exit it doesn't scold you — it just recalculates. A new line appears. You keep driving.
The route was never the point. The destination was — and the quiet, constant correcting toward it. That gap — between handing over a rigid list of steps and handing over a place to get to — is the whole difference between a program and an agent. It's also the last part of the car we've been taking apart, and the one that makes all the others finally move.
The thing that took me too long to see
A program does the steps you wrote. An agent is handed a goal and finds the steps itself — by acting, seeing what actually happened, and adjusting. You stop giving it the route. You start giving it the destination.
That's the shift. Not more intelligence — the smartest text on earth still can't get anywhere on its own. What turns thinking into doing is closing the loop: it makes a move, the world answers back, and that answer changes the next move. An answer becomes an agent the moment the world gets to reply.
How the car actually drives
This is where every part you've met stops being a separate idea and becomes one machine in motion.
- You give a destination, not directions. "Get the tests passing," not "open this file, change line 40, save, run." The goal, not the keystrokes.
- It makes a move — through its wheels. It acts on the real world using the tools from Part 4: runs the code, queries the data, edits the file. One turn toward the destination.
- It looks at what actually happened. The world talks back — the test still fails, the file wasn't there. That reply is data, not the end. It's the road telling the driver where it really is.
- It adjusts and goes again. Remembering the trip so far, still aimed at the same destination, it reroutes — a different move, informed by what just happened. Until it arrives, or you tell it to pull over.
Notice what just happened: the loop didn't replace the other parts. It used them. The engine to think, the desk to remember the trip, the persona to stay who it's meant to be, the wheels to act, the gauges to know if it's on the road. The loop is the driver that makes the whole car go.
You don't give it the route.
You give it the destination.
You've now seen the whole car
Step back and look at what you've assembled, part by part. An engine that was never the real bottleneck (Part 1). A small desk it thinks on, so what you set in front of it is almost everything (Part 2). A driver you can tell who to be (Part 3). Wheels that let it touch the real world instead of only describing it (Part 4). Gauges that tell it where it can trust itself and where it's guessing (Part 5). And now, the thing that turns all of that into motion: a destination, and a loop that drives toward it — acting, reading the road, correcting — until it arrives.
That's not a chatbot answering questions. That's a car that drives itself somewhere, with you deciding where. Once you can see all six parts, you can look at any AI product and name what's under the hood — and, just as usefully, what's missing. No memory management? It'll forget the trip. No real tools? It can only talk. No gauge? It'll drive confidently into a ditch. No loop? It answers once and stops.
If you've followed the series this far, you've also just seen the machine behind the agents I've been running quietly — the second brain, the assistants that actually do things, not just talk about them. Not one of them is a smarter model. Each is a better-built car.
TRY IT — 5 MINUTES
Open Claude Code (or any agent that can run tools). Give it a destination, not directions — then say nothing about how:
"organize this messy folder into subfolders by file type"
Just watch. It lists what's there (acts), sees what it got (the world replies), moves a file, looks again — looping toward the goal. Do not help it. Watch for the one moment that matters: when it hits something it didn't expect and adjusts. That reroute — the correction you can see with your own eyes — is agency. Not the paragraph it wrote. The turn it made because the world told it something it didn't expect.
FOR THE CURIOUS — WHAT'S ACTUALLY HAPPENING
Strip the analogy and the mechanism is plainer, and more modest, than "plan, act, observe, correct" makes it sound: receive the current state → choose an action → execute it → observe the result → continue or stop. "Planning" inside that can be explicit, implicit, or genuinely absent — all three run in production today. One well-known pattern, ReAct, showed that interleaving a written reasoning trace with each action improved reliability over acting blind.1 A good pattern to know — not the definition of an agent.
The "goal, not the route" part has a name too: goal-directed behavior. You specify an objective and a stopping condition; the system searches for actions that satisfy it. The wheels (Part 4) are how it acts; the gauges (Part 5) are how it decides an action helped — which is why an agent turned loose in a domain with no clean scoreboard tends to drive confident and lost. Runtime feedback (the world replies within this task, now) is a different clock from the training-time feedback that made the model good in the first place.
The honest hard part is what happens when the loop goes wrong. It can run away — nothing stops it. It can get stuck — the same failing move, again and again. Or it can act on a stale or misread reply — building three confident steps on a mistake. Bounding the steps and checking the quality of each observation aren't defensive paranoia; they're the actual engineering. "Just add a loop" is the easy twenty percent.
SOURCES & NOTES
- Yao, Zhao, Yu, Du, Shafran, Narasimhan, Cao, "ReAct: Synergizing Reasoning and Acting in Language Models" (arXiv:2210.03629, 2022) — reasoning and acting interleaved, presented as one influential pattern, not a universal definition.
You understand how the car works now. The only question left is how you build a good one — the difference between an agent that limps and one that flies. That's a different craft, and it's where we go next.