In Part I of this series, McElory Hoffmann argued that what makes a system an agent is not its tools or its cleverness but its authority: an agent is given an objective, deliberately incomplete instructions, and the mandate to work out the rest. At the end of that piece, he sketched the process an agent runs (sense, plan, act, reassess) and noted that reassessment is the stage everyone forgets.
This post picks up exactly there. If Part I answered what an agent is, this one answers how an agent works: the loop it runs, the parts of that loop, and why the loop looks strangely familiar once you see it whole.
Every agent has a secret mission
Say the word “agent”, and most people picture the same man: dark suit, sunglasses, earpiece, serious face. Someone on a secret mission.
The picture is more useful than might seem. What makes the secret agent an agent is not the gadgets. It is the shape of his assignment: he has been entrusted with a mission, sent into a situation his principal cannot fully foresee, and expected to work out the method himself. Headquarters gives him the objective. The field gives him everything else.
The word carries this meaning in its bones. Agent comes from the Latin agere: to act, to drive, to carry out. An agent is one who is sent to act on another’s behalf. And the “secret” in secret agent points at something every real agent shares: the mission brief is always incomplete. If the instructions were complete, you would not need an agent. You would need a courier.
That is Part I’s authority argument, seen from the inside. Now let us watch it run.
Start with your fridge
It is midnight. The kitchen is dark. The fridge door stands slightly open, and that cold slice of light falls across the floor. There it hums: the quietest worker in your house.
Here is a strange claim: your fridge is an agent. A very modest one: the AI textbooks would call it a simple reflex agent, the same family as the thermostat. It senses: the temperature is rising. It acts: the compressor kicks in. The temperature drops. It senses again. It acts again. All night, every night.
Sense, act. Sense, act. That is a loop, and a loop is the beginning of agency. But it is a very thin loop, and to see why, we need to look at the full one.
The full loop has four movements
Full agency runs through four movements, and they run in a circle:
Sense. Take the world in. Perception, data, the arrival of the situation. Note the direction: sensing is receptive before it is active. An agent does not begin by reaching out; it begins by being reachable, open to being surprised by what arrives.
Comprehend. Make sense of what arrived. This is more than registering a reading; it is judging what the situation means against some standard: what matters here, what should be the case, what the moment calls for. Comprehension is where a measurement becomes a situation.
Act. Close the gap between the situation as it is and the situation as the objective asks it to be. Not by following a recipe, the recipe was never supplied, but by choosing a method fit for this case.
Reflect. Evaluate what the acting has done. This is the movement Part I flagged as the one everyone forgets, and it is categorically different from the other three: sensing, comprehending and acting all operate against the agent’s standard, while reflection is the operation that examines the standard itself. A system that only measures its outputs against a fixed objective is looping. An agent that can ask whether its approach was the right one is reflecting.
Now look back at the fridge. It performs two of the four movements. It senses, and it acts, but it comprehends nothing, and in its whole cold life it has never once reflected. Its loop is real but thin: the objective (four degrees) and the method (run the compressor) were both installed by someone else’s hand. Part I called this configuration automation: goal plus method, fixed in advance. The fridge is a train on rails: it cannot get lost, nor can it choose a better route.
How AI agents run the loop
What makes today’s AI agents genuinely new is that they run all four movements, and they receive only the goal, not the method. The train (think back to the example of the fridge) becomes a hiker: the peak is pointed out, three paths lead up the mountain, and nobody says which one to take.
Watch a modern agentic system handle a task: “reconcile these invoices against the payment records and flag the exceptions”, and the four movements are clearly visible:
It senses. It reads the files, queries the database, calls a search tool, and inspects what came back. Its senses are its context: documents, APIs, tool outputs, the growing record of its own previous steps.
It comprehends. It builds a plan. It interprets what it sensed against its objective: these two records disagree; that column is dates, not amounts; this exception matters and that one is noise. In engineering terms this is the planning and reasoning step: the model deciding what the situation means for the mission.
It acts. It executes: calls the tool, writes the code, drafts the email, updates the record. Crucially, it chooses which action from an open set, that is the delegated authority Part I described.
It reflects. It ingests the result of its own action, the error message, the test failure, the unexpected reply, and revises the plan before the next pass. This is also why Part I insisted the loop is cumulative, not circular: each pass around the loop deposits state, and the agent that arrives back at “sense” is not the agent that left. Without that accumulation, you do not have an agent; you have a fridge with better marketing.
And when agentic systems fail in production, the failure almost always lives in the fourth movement, exactly as Part I warned. The agent that ignores feedback, repeats a failing approach, or drifts off-objective is an agent whose reflection has quietly collapsed back into looping. In our delivery work at Praelexis, designing that fourth movement, what the agent does with the results of its own actions, and when a human gets pulled in, is where most of the real engineering effort goes.
The loop was not invented for machines
Here is the turn worth sitting with. Nobody designed this loop for AI. Look at where else it shows up.
The scientific method: hypothesis, experiment, observation, revision. The quality cycle every operations team knows: plan, do, check, act. The way you handled your last difficult project: you took stock, you formed a view, you moved, and afterwards. In the car, in the shower: you replayed what happened and adjusted. Sense, comprehend, act, reflect. It is not a machine architecture. It is a description of how competent humans have always operated, discovered independently by every discipline that ever had to act under uncertainty.
So when the architecture of an AI agent looks like this loop, the resemblance is not a coincidence and not an accident of engineering fashion. We built these systems in the image of our own way of acting. That is the quiet confession inside the name: we call it artificial intelligence because it is intelligence made after the human: post-human in the oldest sense of the word, the way a portrait is painted after a sitter. The machines joined our loop. We did not join theirs.
Which raises the question that matters for anyone deploying these systems: if the machine now runs the same four movements we do, what, if anything, still separates its loop from ours? The answer is that the four movements are only half the framework. Between each movement and the next stands a gate, and the gates are where agency actually lives.
That is Part III.