What Is Agentic AI, and Why Is Everyone Suddenly Talking About It?

If you have spent any time near the technology press recently, you will have noticed that the word “agentic” has quietly taken over. Where last year everyone wanted a chatbot, this year everyone wants an agent. The shift is real, but the hype has run well ahead of the substance, and it is worth slowing down to ask what agentic AI actually means, what it can genuinely do today, and where the marketing outpaces reality.

From answering questions to getting things done

The mental model most people have of AI is the chatbot: you ask a question, it gives an answer, the exchange ends. That is a prompt-and-response system, and it is fundamentally passive. It produces text and then waits for you to do something with it. If you ask it to book a holiday, it will write you a lovely description of how one might book a holiday, but it will not book anything.

Agentic AI is the attempt to close that gap. Instead of giving the model a question and taking back an answer, you give it a goal and a degree of autonomy to pursue that goal. “Find me the cheapest direct flight to Lisbon next month and add it to my calendar” stops being a request for advice and becomes a task to be carried out. The model is no longer just a writer; it is an actor that can take steps in the world. That is the entire shift in one sentence: from generating text about a task to actually doing the task. If you want the concrete, personal version of this, we walk through what it means to hand an AI agent your actual inbox — the same idea at the scale where mistakes cost you something.

The plan, act, observe loop

What makes this possible is a deceptively simple loop. A useful agent runs through three repeating phases. First it plans: given the goal, it works out what step to take next. Then it acts: it takes that step, usually by calling some tool. Then it observes: it looks at the result of that action and feeds it back into its own reasoning. Then it plans again, informed by what it just learnt, and the cycle repeats until the goal is met or the agent gives up.

This loop is what separates an agent from a one-shot model. A plain language model produces a single answer and stops. An agent can try something, see that it did not work, and adjust, much as a person would. Searching for a flight, finding none on the chosen date, widening the search, finding one, and only then moving on to the calendar, is the kind of multi-step, self-correcting behaviour the loop enables. None of the individual steps is magic; the power comes from chaining them together with feedback.

Tools and memory

Two ingredients turn that loop from a thought experiment into something useful. The first is tools. On its own, a language model can only produce text; it cannot search the web, query a database, send an email, or run code. Tools are the bridge to the outside world. The model is told, in effect, “here are the actions available to you and here is how to invoke each one,” and when it decides it needs to search the web, it emits a structured request that your system intercepts, executes, and returns the result of. Conceptually, a tool definition looks like this:

1
2
3
4
5
6
7
8
9

{
  "name": "search_flights",
  "description": "Search available flights between two cities on a date",
  "parameters": {
    "from": "string",
    "to": "string",
    "date": "string"
  }
}

The model never runs the search itself; it asks for it, and your code does the work and hands back the answer for the next turn of the loop.

The second ingredient is memory. A long task can easily exceed what fits in a single conversation, so agents keep some form of memory: notes on what they have tried, facts they have gathered, the state of their progress. Without it, an agent forgets what it was doing halfway through and starts going in circles. With it, it can pursue a goal across many steps and even across separate sessions.

Multi-agent systems

Once you have one agent, the obvious next thought is to use several. Multi-agent systems divide a problem among specialised agents that collaborate, much like a team of people. One agent might plan and delegate, another might research, another might write code, and another might review the result. A coordinating agent hands out sub-tasks and assembles the pieces.

The appeal is clear: specialisation and parallelism. The catch is that coordination is hard, costs multiply with every extra agent, and a mistake by one member can quietly poison the work of the others. For many problems a single well-designed agent outperforms a committee of them, and the multi-agent approach is best reserved for tasks that genuinely decompose into independent parts.

Why this arrived when it did

None of the underlying ideas are new. Researchers have described plan-act-observe loops for decades, and the notion of chaining a model’s outputs back into its inputs predates the current wave of interest by years. What changed is that the models finally became reliable enough at two specific things to make the loop worth running: following instructions closely enough to stay on task, and producing structured output — a clean, machine-readable request for a tool — rather than free-flowing prose. A loop is only as good as each step, and until recently each step was too flaky to chain. Once a model could reliably emit “call the search tool with these exact parameters” instead of “you might want to search for something like this”, the whole architecture became practical almost overnight. That is why the word “agentic” seemed to appear from nowhere: the enabling capability crossed a threshold, and a decades-old idea suddenly worked.

The economics shifted too. Every turn of the loop is a separate call to the model, and each call costs money. When models were both expensive and unreliable, running one twenty times to complete a single task was indefensible. As prices fell and quality rose, the sums started to make sense for real work, and the demos turned into products — the same rough calculus that decides whether self-hosting actually saves you anything once you count the hours as well as the hardware.

What it is actually good at today

Strip away the hype and there are areas where agentic AI is already pulling real weight. Coding is the standout: an agent that can read a codebase, run the tests, see what failed, and edit the code in response is a genuinely useful collaborator, because software development is full of fast, cheap feedback loops that suit the plan-act-observe cycle perfectly. Research and information-gathering is another, where an agent fans out across many sources, collects findings, and synthesises them. Operations tasks, triaging alerts, drafting responses, gathering diagnostic data, are a promising near-term frontier.

The common thread is that these domains offer clear goals and quick, reliable feedback. Where the agent can check its own work, by running a test, reading an error, comparing against a source, it thrives. Where success is fuzzy and feedback is slow or absent, it flounders.

The hype versus the reality

It would be dishonest to pretend the technology is more finished than it is. The demos are seductive; the day-to-day experience is more uneven. Agents still go off the rails, confidently pursue the wrong sub-goal, get stuck repeating the same failed action, or declare victory on a task they have not actually completed. Reliability is the central unsolved problem: a process that is ninety per cent likely to succeed at each step sounds impressive until you chain ten steps together and discover the whole task now succeeds only about a third of the time. Errors compound.

The honest summary is that agentic AI today is a powerful assistant that needs supervision, not an autonomous worker you can leave unattended. It shortens the distance between intent and result, but a human still belongs in the loop for anything that matters.

The risks worth naming

Three risks deserve a clear-eyed mention. Reliability we have covered: agents are not yet dependable enough to trust blindly with consequential decisions. Cost is the second: every turn of the loop is another call to a model, and a task that takes twenty steps costs twenty times a single response, which adds up quickly and can surprise teams that budgeted for a chatbot. Security is the third and most serious. An agent that can take actions, send emails, run code, move money, is only as safe as its weakest input, and feeding it untrusted content opens the door to manipulation, a problem explored in our piece on prompt injection. Give an agent powerful tools and you must assume someone will try to hijack them.

How to try it without getting burned

If you want to experiment rather than just read about it, the sensible entry point is a task that is genuinely useful but where a mistake costs you nothing. Point an agent at a read-only job first: summarising a long document, gathering links on a topic, triaging a folder of files, drafting something you will review before it goes anywhere. Watch what it does at each step rather than only judging the final answer — the failures are almost always visible in the middle of the loop, where it pursues a wrong sub-goal or repeats an action, long before they show up in the output. Give it the smallest set of tools that the task actually needs, and never more permission than the job requires. An agent that can only read cannot delete the wrong thing, and an agent scoped to one folder cannot wander into the rest of your machine.

Two habits make the difference between a useful assistant and a liability. First, keep the reversible and irreversible actions separate: let it read, sort, and draft freely, but put a human check in front of anything that sends, deletes, spends, or leaves the building. Second, resist the urge to hand it the hardest, highest-stakes problem you have just because a demo looked impressive. Start where errors are cheap and recoverable, learn where this particular agent is strong and where it flails, and widen its remit only as it earns the trust — the same posture you would take with a capable but untested new colleague.

A grounded take

Agentic AI is a genuine step forward, not merely a rebranding. Moving from systems that describe what to do to systems that actually do it is a meaningful change, and in domains with tight feedback loops it is already delivering real value. But it is early, it is unreliable in ways that matter, and it is not the autonomous workforce some of the marketing implies. The sensible posture is curiosity without credulity: experiment with it where mistakes are cheap and reversible, keep a human in charge where they are not, and treat anyone promising fully autonomous agents for high-stakes work with the same scepticism you would apply to any technology that sounds too good to be true. The capability is real; the wisdom is in deploying it where its strengths line up with the task and its weaknesses cannot hurt you.