What an AI Agent Actually Is

If the last lesson said an agent takes a goal, plans, uses tools and does multi-step work, this lesson opens the box and names the parts, because you cannot direct - or trust, or debug - a thing you cannot picture. An AI agent, stripped to essentials, is five parts working together, and every agentic system you will ever meet is a variation on them.

One - a goal. The agent starts not from a single question but from an objective you hand it: 'assemble the precedents for a mid-size clinic and tell me what makes them work', 'draft the door schedule from this plan', 'check this layout against these rules'. The goal is the whole job, not one step of it, and how well you frame it largely decides how well the agent does - a vague goal produces confident wandering.

Two - a model, the brain. At the centre sits a large language model (and sometimes more than one): the reasoning engine that reads the situation, decides what to do next, writes the plan, interprets what came back, and forms the words of the result. It is the part that 'thinks', in the loose sense - and, crucially, the part that can be fluently, confidently wrong, which is why nothing downstream escapes verification.

Three - tools. A brain that can only talk is an assistant; a brain that can act is an agent. Tools are the hands: the ability to search the web, read and write files, run a calculation or a script, query a database, call another program or an external service through an interface. Tools are how the agent reaches out of the chat window and changes something in the world - and the set of tools you give it defines the outer edge of what it can possibly do.

Four - memory and context. A multi-step job needs a working memory: what the goal was, what has been tried, what each tool returned, what was learned two steps ago and still matters now. Some of this is the running context of the task; some is longer-term memory the agent can store and retrieve. Without it, an agent forgets its own trail and repeats or contradicts itself.

Five - a loop. The four parts above are wired into a cycle: the agent plans, acts with a tool, observes the result, adjusts, and goes round again until the goal is met or it gives up. That loop is the single feature that separates an agent from everything that came before, and it is worth a section of its own.

The loop is the heart of an agent, so it repays a close look. A plain AI answer is one pass: text in, text out, done. An agent runs a cycle - most usefully described as plan, act, observe, adjust - and it is the repetition of that cycle that turns a language model into something that gets multi-step work done.

Plan. Given the goal and what it knows so far, the model decides the next move: which sub-task to tackle, which tool to reach for, what to ask that tool. Early in a job this is a rough sketch of the whole route; later it is the single next step, revised in light of what has happened. Good agents plan lightly and often rather than committing to one long plan made blind at the start.

Act. The agent uses a tool - it runs the search, opens the file, executes the calculation, calls the service. This is the step that reaches into the world, and it is also where real consequences and real errors live: an action can fail, return garbage, or change something it should not have. Which is exactly why sensitive actions deserve a human gate, a theme the whole course returns to.

Observe. The tool returns something - search results, a file's contents, an error message, a number - and the model reads it. This closing of the feedback loop is what makes an agent adaptive rather than blind: it is not executing a fixed script, it is reacting to what actually came back, which may be nothing like what it expected.

Adjust. In light of the observation, the agent updates its plan: the search was empty, so try different terms; the file had the dimension after all, so move on; the calculation failed, so fix the input and retry. Then it loops - plans the next move, acts, observes, adjusts - again and again.

Two properties of the loop matter for you as its director. First, it terminates - by reaching the goal, hitting a limit you set, or getting stuck - and a well-built agent knows when to stop and hand back rather than spin. Second, it can compound errors: a wrong observation early can send the whole chain astray, plausibly and invisibly. Seeing the loop clearly is what lets you place your checks where they count - on the goal going in, and on the work coming out.

Now the distinction the whole course turns on: the difference between an agent and a plain LLM call. It is easy to blur, because an agent is built around an LLM and often talks to you in the same chat box - but the difference is real and it changes how you must treat the output.

A plain LLM call is a single transformation: you send text (a prompt), the model predicts and returns text (an answer), and that is the entire event. It has no memory of anything beyond what you pasted in, it cannot look anything up, it cannot check its own claim, and it cannot take any action in the world. It is astonishing at what it does - drafting, explaining, rephrasing, brainstorming - but it does exactly one thing: produce a plausible next stretch of text. When it does not know, it does not go and find out; it produces plausible text anyway, which is the root of hallucination.

An agent wraps that same model in the loop and the tools from the last two sections. The consequences are qualitative, not cosmetic. An agent can act, not just describe - it can actually open the file and read the real dimension rather than guessing it. It can take several steps, carrying what it learns forward, so it handles jobs no single prompt could. It can ground itself in reality by using tools to fetch real information instead of relying only on what it absorbed in training. And it can self-correct within limits, noticing a failed step and trying again.

But notice what does not change. The brain is still a language model, so the agent can still be confidently wrong - now with the added reach to act on that wrongness, and to produce a large, polished, multi-part deliverable that is subtly mistaken throughout. A plain wrong answer is easy to catch; a wrong answer buried in fifty pages of correct-looking schedule is not. So the agent's extra power raises the stakes of verification rather than lowering them.

The practical test to keep in your head: did the system just generate text, or did it go and do something and come back? If you asked one question and got one answer, that is an assistant call, and you judge it as a claim. If you handed over a goal and it planned, used tools and returned completed work, that is an agent, and you judge it as work - which means checking not just the conclusion but the steps and sources it took to get there.

Knowing the anatomy is not trivia; it is what lets you direct an agent well and diagnose it when it fails, which it will. Almost every disappointing agent result traces back to one of the five parts, and naming the part turns a vague 'the AI is bad' into a fixable problem.

A bad goal is the commonest failure and the one entirely in your hands. If the objective is vague, contradictory, or missing a constraint that mattered, the agent will pursue the wrong thing with total confidence. The fix is upstream: state the goal, the constraints, the format you want, and what 'done' looks like - Module 2.1 is devoted to this. A missing or wrong tool shows up as an agent that talks about doing something instead of doing it, or that guesses a fact it could have looked up; the fix is to give it the right tool, or to stop asking for what it has no way to reach. Lost context shows up as an agent that forgets an instruction, contradicts an earlier step, or repeats work; the fix is to manage what stays in its memory (Module 1.3). A runaway or stalled loop shows up as an agent that spins, repeats the same failing action, or stops too early; the fix is clearer stopping conditions and checkpoints.

And running through all of it is the model's fallibility, which no amount of good wiring removes. The brain can misread, invent, and reason wrongly, so the anatomy always has a sixth part that lives outside the machine: you. The human is not a component of the agent; the human is the one who sets the goal, chooses the tools, decides what the loop is allowed to do unwatched, and - above all - judges the result and answers for it. An agent is a powerful arrangement of goal, brain, tools, memory and loop; a professional outcome is that arrangement plus a designer who directs it and verifies its work.

Carry this picture into every lesson that follows. When an agent delights you, it is these five parts working; when it fails you, it is one of these five parts - or your direction of them - that broke. Either way, you are never at the mercy of a black box. You are the operator of a machine whose parts you can name.