"Agent" has become the most overused word in AI, slapped onto everything from a slightly-better chatbot to a glorified macro. The inflation is unfortunate, because there's a real and important distinction underneath the hype. Understanding what genuinely makes something an agent — versus a model with marketing — clarifies both why agents are exciting and why they're so hard to get right.

The actual definition

At its core, an AI agent is a system that pursues a goal by taking actions in a loop. The loop has a recognisable shape: the system forms a plan or decides on a next step, it acts — typically by using a tool, calling an API, running code, searching, or otherwise affecting some environment — it observes the result of that action, and it adjusts its next step based on what it observed. Then it does it again, until the goal is met or it gives up.

That loop is the whole thing. A model that answers a question in one shot is not an agent, however capable. An agent is defined not by how smart its underlying model is but by its ability to act, observe, and react over multiple steps. The intelligence is necessary but not sufficient; the loop is what makes it an agent.

Why the feedback loop is everything

The distinction matters because the feedback loop is what unlocks a completely different class of task. A one-shot model can only produce an answer from what it already knows. An agent can find out — it can run a search and read the result, execute code and see whether it worked, call a system and get fresh data, then use that new information to decide what to do next.

This is the difference between a system that reasons about the world from memory and a system that interacts with the world to accomplish something. The latter can, in principle, complete tasks that no amount of one-shot cleverness could: multi-step research, debugging by running and observing, workflows that require gathering information the model never had. The loop lets the system bootstrap — each action produces information that informs the next.

The components that make this work — tool use (the ability to call external functions and act on the world), memory (carrying state across steps), and some planning or control structure (deciding what to do next) — are all in service of that loop. Strip the loop out and the rest is just a fancy text generator.

Why agents are fragile

Here's the catch, and it's the reason agents are simultaneously the most exciting and least reliable area of applied AI: errors compound across steps.

A single model response has one chance to be wrong. An agent taking ten steps toward a goal has ten chances, and worse, the steps are dependent — a mistake early in the chain corrupts everything downstream. If step three misreads a result, steps four through ten build confidently on a false premise. The system can wander off, loop uselessly, or pursue a plan that made sense only because of an earlier error. A 95%-reliable step sounds great until you chain ten of them and your end-to-end success rate collapses toward a coin flip.

This is why the frontier of agent research isn't really about raw capability — it's about reliability. How do you keep an agent on track over a long horizon? How does it recognise when it's gone wrong and recover? How do you verify intermediate steps so errors get caught before they compound? How do you keep it from confidently barrelling toward a goal it has misunderstood? These reliability questions — not whether the underlying model is smart enough — are what stand between today's impressive-but-flaky agents and dependable ones.

The honest state of play

So when you hear "agent," the useful test is simple: does it take actions in a loop and react to what happens, or does it just respond? The genuine agents are doing something qualitatively more powerful than chatbots — and paying for it in fragility. The breakthroughs that matter from here won't be the demos of agents doing impressive things once. They'll be the unglamorous advances that let agents do useful things reliably, step after step, without the errors compounding into nonsense. That's the real problem, and it's far from solved.