No term in AI is doing more marketing work than "agent." It's attached to everything from a chatbot with one function call to fully autonomous systems. Cut through it and the concept is simple — and so are the reasons agents are simultaneously powerful and unreliable.

What an agent actually is

An agent is an LLM running in a loop with access to tools. The loop looks like: the model decides what to do, calls a tool (search the web, run code, query a database, click a button), sees the result, and decides what to do next — repeating until the task is done. That's it. The intelligence is the model's; the agency is the loop's; the reach is the tools'.

Everything good and bad about agents flows from this structure. The loop lets the model break a goal into steps, react to what it finds, and recover from surprises — far more powerful than a single prompt. But the loop is also where errors compound.

Why long-horizon agents are fragile

Here's the core problem, stated plainly. Suppose the model makes the right call 95% of the time at each step — which is good. Over a 20-step task, the chance of getting every step right is roughly 0.95²⁰, about 36%. Over 50 steps it's vanishingly small. Errors don't average out across a long chain; they compound. One wrong turn early can send the whole task off a cliff, and the agent may not notice it's lost.

This is why agents are impressive in demos (short, curated tasks) and frustrating in production (long, messy ones). The longer the horizon and the more steps required, the more likely the agent derails. It's not that the model is bad; it's that even a small per-step error rate is fatal over enough steps without correction.

Where agents genuinely work

The successful pattern isn't "give the agent a vague goal and walk away." It's tight scoping and built-in checks:

Bounded tasks. Agents do well when the task is well-defined and reachable in a modest number of steps. "Find this information across these sources and summarise it," "make this specific code change and run the tests." Clear goal, limited horizon, checkable result.

Verifiable outcomes. Agents thrive where success can be checked automatically — code that must pass tests, output that must match a schema, a result the agent can validate before declaring victory. Verification lets the loop self-correct instead of confidently finishing wrong.

Recoverable actions. Tasks where a mistake is cheap to undo are far safer to automate than ones where a wrong action causes irreversible harm.

How to build agents that work

Constrain scope ruthlessly. Decompose big goals into small, well-defined sub-tasks rather than handing the agent one sprawling objective. Shorter horizons mean higher reliability.

Build in verification. Give the agent ways to check its own work — run the tests, validate the output, confirm the action landed — so the loop catches errors instead of accumulating them.

Limit the blast radius. Scope the agent's tools and permissions to what the task needs. An agent that can only read shouldn't be able to delete. Restrict, sandbox, and require confirmation for high-stakes actions.

Keep a human in the loop where it matters. For consequential or irreversible actions, have the agent propose and a human approve. This isn't a failure of automation; it's how you ship automation safely while the technology is still unreliable on long horizons.

Make it observable. Log what the agent did at each step. When it fails — and it will — you need to see where the loop went wrong to fix it.

The honest summary

Agents are real and useful today for bounded, verifiable, recoverable tasks with a human watching the high-stakes moments. They are not yet reliable for long-horizon autonomous work where they're expected to plan and execute dozens of steps unsupervised — the compounding-error problem is fundamental, not a bug to be patched away soon. Build for the regime that works now, design for a human safety net, and you'll ship agents that genuinely help instead of demos that fall apart in contact with reality.