“Agent” might be the most over-promised word in software right now. It conjures something autonomous and a little uncanny — a digital employee that thinks, decides, and acts while you sleep, summoned by the right incantation and capable of almost anything. So let’s do the opposite of hype for a moment and strip the word all the way down to what’s actually running underneath. Because once you see the real shape of it, the magic doesn’t disappear. It just stops being mysterious, and starts being something you can trust.
Here’s the whole thing, with nothing hidden: an agent is a model, in a loop, with tools. That’s it. Everything else — the autonomy, the follow-through, the sense that it’s working — grows out of those few words. So let’s slow down and look at each one.
the loop is the whole trick
Picture how you’d actually get a piece of work done at a computer. You look at the situation. You do something — run a command, write a note, check a file. You look at what happened. Then you decide what to do next, and you do it. You keep going around like that until the job is finished.
That’s an agent. Truly, that’s the entire machine.
A model (the AI) reads what’s in front of it. It picks an action and takes it. It reads the result of that action. Then it goes around again, with the result of the last step now part of what it’s reading. It keeps circling — read, act, look, repeat — until it decides the work is done, or it runs out of room to keep trying. No planner pulling strings behind a curtain, no graph engine, no pile of abstractions you have to take on faith. One loop, going around.
Once you can see that loop, the strange behavior of agents stops being strange. When an agent “works for twenty minutes,” what’s actually happening is that loop turning, over and over, each pass building on the last. When it does something puzzling, you can read back exactly what it saw and what it chose at each turn. There’s no hidden mind to interrogate — just a transcript of the trip around the loop.
a model, with tools
The model on its own can only produce words. To do real work, it needs hands — and in this ecosystem, an agent gets exactly one hand: a shell, the same kind of command line a person would type into. That’s deliberate, and it’s the cleverest part of the design.
Every other capability comes from toolkits — real programs sitting ready to be run, each one carrying its own manual that teaches the agent how to use it. There’s no custom wiring for every new ability, no sprawling matrix of plugins to maintain, no zoo of competing protocols. An agent that can read a manual and run a command can use anything the ecosystem offers — the very same way you could, if you sat down at that command line yourself.
So when people say an agent “uses a tool,” picture this: it reads the manual for the thing it needs, then runs the command. That’s the whole interaction. The agent isn’t granted secret powers; it’s handed a workbench and taught to read the labels.
from conversation to tenure
Here’s where most agents in the wild go wrong, and where the real idea lives.
The industry tends to run agents the way you’d run a vending machine: a message goes in, an answer comes out, and then the thing vanishes. Summoned, used, gone. And then everyone acts surprised when these agents forget everything, repeat work they already did, and can’t be trusted with anything longer than a single chat.
But nothing about an agent has to be that fleeting. The entire point — memory, files, schedules, following through on something over days — is about time. People feel this so strongly that some have literally parked spare computers in their closets just to give an agent somewhere permanent to live. The instinct is exactly right, even if the closet is a little silly. An agent isn’t a thing you summon. It’s a long-running worker you give a place to exist.
The mental shift is from conversation to tenure. You don’t call an agent up for a quick answer; you give it a workspace and a rhythm, and it carries work forward between the times you check in. To do that, an agent needs the same four things a human colleague needs from a computer:
- Files — a workspace of its own to keep things in.
- Processes — real programs it can actually run, safely walled off.
- Memory — not a database bolted on the side, but notes and decisions and task states it reads and writes the way you do.
- Time — the ability to keep existing while you’re away, on a schedule, with persistence.
Notice what’s not on that list: your operating system. An agent here never touches it. That isn’t a polite promise — it’s built into the structure, which is its own lesson later on.
The missing sense, in most agents today, is precisely that fourth one — time. Ask an ordinary agent the questions that actually matter on real work — when did this happen? why did we decide that, back then? what was I in the middle of? — and it shrugs. Its memory holds text, but not chronology. An agent that can answer “what was I doing, and why” is the difference between a goldfish and a colleague.
agents, not autopilot
This is the honest part, and it matters more than any feature.
The pitch is never “software that runs itself.” It’s people and AI building together. An agent carries work between your sessions, writes down what it found, and stops at the edges you set. Direction stays human. The loop makes the work get done; it doesn’t make you optional.
And the edges are real, not wishful. An agent’s reach — the most damage it could possibly do — is confined to its own little workspace. Its abilities are things you explicitly hand it, not powers it grabs for itself; trust flows down to an agent from you, never up from the agent. And whatever it changes, it changes in a layer you can read, compare against yesterday, and undo. Trust gets earned in small increments, and the whole thing is built so that those increments are safe to give.
That’s why every action an agent takes leaves a record you can read back. You should never have to guess what it did while you were away. The record of its work — the notes it kept, the tasks it moved along — is its timesheet. “Catch me up on what happened” becomes a real, answerable request instead of a hopeful one.
So here is the word, demystified. An agent is a model, running in a loop, reaching for tools — and given files, memory, and time, it becomes a worker with tenure rather than a function you summon and forget. Everything else in this unit is just following that loop into the rooms it opens: the run itself, one turn at a time; the file where an agent is defined; and the place agents live while they wait for the next thing to do. None of it is magic. All of it starts here, with one loop, going around.