Agentic AI: where the hype outruns reality

Agentic AI is the current favourite phrase in a field that produces a new favourite phrase every few months, so it’s worth being careful. Stripped of the excitement, it means AI that can take actions to accomplish a goal, rather than just producing an output for a human to then act on.

The distinction is simpler than it sounds. A regular AI tool answers or generates: you ask, it responds, you decide what to do with the response. An agentic system is given a goal and then takes steps toward it on its own, deciding what to do, doing it, checking the result, and adjusting, with less human involvement at each step.

The plain version: normal AI tells you things, agentic AI does things. That shift, from a tool you operate to a system that operates, is real and genuinely significant. It’s also surrounded by more hype than almost anything else in technology right now, so this piece tries to give you the honest shape of it: what it actually is, what it can and can’t do today, and how to tell a real use from a demo that falls apart in production.

What makes AI agentic

Three capabilities separate an agentic system from a regular AI tool, and a real agent has all three.

It can act, not just respond. A normal model produces text or an image. An agentic system can do things: call other software, search, send a message, update a record, trigger a process. The output isn’t the end; it’s a step toward doing something.

It works toward a goal over multiple steps. Rather than one prompt and one answer, you give it an objective and it breaks that into steps, does them in sequence, and keeps going until the goal is met or it gets stuck. This multi-step, self-directed quality is the heart of “agentic.”

It adjusts based on what happens. After each action it can look at the result and decide the next move, changing course when something doesn’t work rather than mindlessly following a fixed script. This is what separates an agent from ordinary automation, which does the same steps every time regardless.

Miss any one of those and you don’t really have an agent. A model that only responds is a tool. A system that acts but can’t adjust is automation. An agent acts, pursues a goal across steps, and adapts. Holding that line matters, because a lot of things get called agentic that are really just one of the three wearing the label.

The loop

At the centre of every agentic system is a loop, and understanding it demystifies the whole idea.

The loop has four moves. It perceives, taking in the current situation and what’s happened so far. It decides, choosing the next action based on the goal and the state. It acts, doing the thing. It observes, seeing what resulted. Then it goes back to the start with that new information and repeats, until the goal is reached or it determines it can’t proceed.

That’s it. That’s the mechanism under the impressive language. A human doing a task does roughly the same thing without naming it: look at where you are, decide the next step, do it, see what happened, repeat. An agentic AI runs that loop in software, with a model making the decisions.

Once you see the loop, two things become obvious. The power is real, because a system running this loop can handle tasks that don’t have a fixed set of steps, adjusting as it goes. And the risk is equally real, because a system taking actions in a loop with reduced human oversight can also do the wrong thing repeatedly and quickly. The loop is the source of both, which is why serious use is mostly about controlling the loop, not just starting it.

In practice

Concrete examples help, and it’s worth separating what genuinely works now from what makes a good demo and a bad deployment.

Working reasonably well today are narrow, bounded agents. A coding assistant that writes code, runs it, sees the errors, and fixes them, looping until the tests pass. A research agent that searches, reads, searches again based on what it found, and assembles a summary. A support agent that handles a defined set of requests end to end, escalating when it hits something outside its scope. What these share is a bounded domain, a checkable result, and a sensible fallback when stuck. That combination is where agentic AI earns its keep right now.

More fragile is the sweeping version: the fully autonomous agent that runs your whole workflow, makes consequential decisions unsupervised, and handles anything you throw at it. These demo beautifully and disappoint in production, because the wider the scope and the higher the stakes, the more the small error rate of each step compounds across many steps into unreliable overall behaviour. An agent that’s 95% reliable per step is impressive; run it for twenty dependent steps and the odds it gets all twenty right are barely better than a coin flip.

That compounding is the single most important practical fact about agentic AI, and the one the hype most consistently ignores. Reliability doesn’t add, it multiplies, and it multiplies downward. The teams getting value are the ones who kept the number of consequential unsupervised steps small.

Following one agent through a task

Watching the loop run on a real task makes the whole thing concrete, including where it can go wrong, so here’s a modest, realistic one.

Suppose you point a coding agent at a failing test and tell it to make the test pass. That’s a good agentic task: bounded, with a result you can check automatically.

It perceives: it reads the test, the error message, and the relevant code. It decides: the error says a function returns the wrong value, so it plans a change. It acts: it edits the code. It observes: it runs the test again. The test still fails, but with a different error now, which is progress. Loop. It perceives the new error, decides on another change, acts, observes. This time the test passes. The agent stops, because the goal is met and it can tell the goal is met.

That worked because three things were true. The task was bounded, one failing test, not “improve the codebase.” The result was checkable, the test either passes or it doesn’t, so the agent had honest feedback at every step. And there was a natural stopping point, so it didn’t wander.

Now change one thing and watch it degrade. Tell the same agent to “improve the app’s performance.” Suddenly nothing is bounded, there’s no single check for success, and no clear stopping point. The agent makes a change, can’t really tell if it helped, makes another, maybe breaks something it can’t detect because there’s no test watching that part, and loops on, accumulating changes with no reliable signal. Same technology, same loop, wildly worse outcome, purely because the task lost its edges.

That contrast is the whole practical lesson. The agent didn’t get less capable. The task got less checkable, and checkability is what an agent runs on. When people say agentic AI “didn’t work for us,” this is usually what happened: a good mechanism pointed at a task that couldn’t give it honest feedback.

Hype vs reality

I want to be straight about this, because the gap between the pitch and the present is wide.

The pitch is that autonomous agents are about to run whole businesses, replace large chunks of knowledge work, and operate independently at scale. The present is that narrow agents doing bounded tasks with a human watching are useful and real, and everything beyond that is somewhere between “promising but unreliable” and “not yet.”

None of the limitations mean the technology is fake. Narrow agentic systems genuinely work and genuinely help. It means the timeline and the scope are oversold, as they always are early in a hype cycle. The reasonable position is neither dismissal nor breathlessness: this is a real capability with real current uses and real current limits, moving fast enough that the limits are worth rechecking, and hyped enough that confident claims about what it’ll do next year deserve scepticism.

One more honest note. This area moves quickly, and specific limitations described here may ease over time. The compounding-reliability problem, though, is structural rather than a temporary rough edge, so while agents will get more reliable per step, the multiplication maths doesn’t go away. Design around it rather than waiting for it to disappear.

A readiness worksheet

The difference between an agentic project that works and one that embarrasses you is mostly about scope, checkability, and oversight, not about how clever the model is.

We’ve put it into a short readiness worksheet: a check on whether your intended task is bounded, whether each step’s result can be verified, how many consequential steps run without a human, and what the fallback is when the agent gets stuck. There’s also a compounding-reliability estimate, so you can see what a plausible per-step error rate does across the length of your task before you find out in production. If the task is broad, unverifiable, and unsupervised, the worksheet will tell you to narrow it before you build.

How to start

If you want to use agentic AI without getting burned, a few principles hold up.

Start narrow. Pick one bounded task with a checkable result, not a sprawling workflow. The narrow win teaches you how these systems behave on something you can actually supervise.

Keep a human at the consequential moments. Let the agent do the many small reversible steps freely, and put a person at the few points where a mistake is expensive or hard to undo. This preserves most of the value while capping the downside.

Make results checkable. Agents work best when success is verifiable: tests pass, a total reconciles, an output matches a format. If you can’t tell whether a step worked, the agent can’t either, and neither of you should trust the outcome.

Have a fallback. Decide in advance what happens when the agent gets stuck or does something wrong. A good agent knows when to stop and hand over. A system with no fallback fails silently and expensively.

Expect to supervise more early. Trust is earned by observation. Watch closely at first, learn where it’s reliable and where it isn’t, and widen its latitude only where it’s proven. The teams that hand an unproven agent full autonomy on day one are the ones who generate the cautionary tales.

The stuff worth remembering

Agentic AI takes actions toward a goal rather than just producing an output for you to act on. Normal AI tells you things; agentic AI does things.
A real agent has three traits: it acts, it pursues a goal across multiple steps, and it adjusts based on results. Miss one and it’s a tool or plain automation.
At its centre is a loop: perceive, decide, act, observe, repeat. That loop is the source of both the power and the risk.
Narrow, bounded agents with checkable results work today. Sweeping autonomous agents demo well and disappoint in production.
Reliability compounds downward across steps. A 95%-per-step agent is close to a coin flip over twenty dependent steps. This is the key practical fact.
The compounding problem is structural, not a temporary limitation. Design around it rather than waiting for it to vanish.
Start narrow, keep humans at the consequential moments, make results checkable, and always have a fallback.

Wondering whether agentic AI fits a real problem you have?

For context, compare it with generative AI, revisit what AI is, and see what generative AI actually does.

The useful version of this conversation starts with one bounded task where the result is checkable, not with a grand autonomous vision. If you’d like a second opinion on whether a specific workflow is a sensible candidate, or whether it’s one of the ones that only works in a demo, get in touch and we’ll work through it with you.