An agentic AI system is software that is given a goal rather than a set of instructions, and works out for itself what steps to take to reach it.
That is the whole idea. Everything else is detail.
The word “agentic” comes from agency — the capacity to act independently. A traditional program does what you told it. An agent does what you asked for, deciding the how as it goes.
The difference in one example
The task: a supplier invoice arrives by email. It needs checking against the purchase order and either approving or flagging.
Traditional automation follows a script you wrote:
- Watch the inbox
- If the subject contains “invoice”, save the attachment
- Read field X from position Y
- Look up the PO number in the database
- If the totals match, approve
This works until an invoice arrives in a layout you did not anticipate. Then it breaks, or worse, reads the wrong number from the wrong place and carries on confidently.
An agentic system is given the goal:
“Check this invoice against our purchase orders. Approve it if it matches. Flag it for a human if anything is wrong or unclear.”
It reads the document in whatever layout it arrives, works out which number is the total and which is the PO reference, queries the system, notices that the quantity matches but the price is 4% higher, recognises that this falls outside tolerance, and escalates it with an explanation of what it found.
Nobody told it what to do about a 4% price variance on an unfamiliar layout. That is the difference.
The four parts of every agent
Whatever the vendor calls it, every agentic system has the same four components.
1. A goal. What it is trying to achieve, expressed as an outcome rather than a procedure. This is the part people under-specify, and vague goals produce unpredictable agents.
2. Tools. The things it can actually do — read a database, call an API, send an email, write a file, search a document store. An agent with no tools is a chatbot. The tool list defines what it is capable of and, just as importantly, what it is not.
3. A loop. The agent observes the situation, decides on an action, takes it, observes the result, and decides again. This repeats until the goal is reached or it gives up. The loop is what makes it agentic — and it is also what makes costs scale, because every pass through it is a paid model call.
4. Boundaries. What it may not do, how many steps it may take, how much it may spend, when it must stop and ask a human. These are not optional. An agent without boundaries is the thing that generates the horror stories.
What makes it different from “AI” generally
“AI” covers a lot. Three distinctions are worth holding:
A language model is the engine. It turns text into more text. On its own it cannot do anything — it has no access to your systems and no memory of what it did a minute ago.
A chatbot or assistant is a language model with a conversation wrapped around it. It answers. It does not act.
An agent is a language model with tools, a loop and boundaries. It acts.
The practical consequence: a chatbot that is wrong gives you a bad answer, and you notice. An agent that is wrong takes a bad action, and you may not.
That asymmetry is why agentic systems need audit logs, confidence thresholds and escalation paths, and why the ones built without them tend to be switched off.
Where the autonomy is worth having
The path varies but the goal does not. Invoices arrive in forty layouts. The job is always the same: check it against the PO. Automation struggles with forty layouts; an agent handles them because it understands the task rather than the format.
Exceptions are the norm. If a third of cases need judgement, a script that handles only the clean two-thirds leaves most of the work with a human anyway.
The inputs are unstructured. Emails, PDFs, scanned documents, free-text notes. Anything where the information is there but not in neat fields.
Multiple systems must be consulted. An agent can decide which system to check based on what it found in the last one. A script has to have that decision tree written out in advance.
Where the autonomy is worth paying for — in practice
The abstract case is easy. Here is what it looks like in a real business.
A wholesaler receiving delivery notes. Forty suppliers, forty layouts, some scanned, some photographed on a phone in a loading bay. A script handles the three suppliers who send consistent PDFs. An agent handles all forty, because it reads the document rather than reading field positions.
A practice receiving client documents. Certificates, insurance schedules, identity documents. Each one needs checking for expiry, completeness and whether it matches the client record. The checks are the same; the documents never are.
An operations team triaging exceptions. Stock discrepancies, failed deliveries, pricing queries. Each needs information gathered from two or three systems before a decision. The gathering is identical work; what to gather depends on what the exception turns out to be.
Where the autonomy is a liability
When you need the same answer every time. Agents are not perfectly deterministic. If a process must produce an identical result on identical input, every time, with no variation, write the rule in code.
When being wrong is expensive. An agent that is right 95% of the time is strong performance. If each of the remaining 5% costs more than the labour you replaced, the arithmetic fails.
When the decision must be explainable to a regulator. Agents can explain their reasoning, but that explanation is generated text rather than a traceable rule. For decisions that must be justified formally, use AI to inform rather than to decide.
When nobody is watching. Agents drift as models update and your data changes. Without someone monitoring accuracy, degradation is silent.
Three things people get wrong about them
“It learns from our data as it goes.” Generally no. The model does not update itself from your corrections. It appears to learn within a single task because earlier steps are in its context, but once the task ends that is gone. Improvement comes from you changing the instructions, the tools or the data it can reach — which is a deliberate act, not an automatic one.
“It will get better on its own.” The opposite is nearer the truth. Behaviour drifts as providers update models and as your data shifts. Without an evaluation suite re-run on a schedule, a system quietly degrades and nobody notices until the exception rate has tripled.
“We can just tell it the rules.” You can, up to a point. Past a certain volume of instructions, adding a rule for one case degrades accuracy on unrelated cases — the rules start competing. That is the signal to split the work, and the point at which multi-agent architecture is genuinely justified.
The question people actually want answered
“Is this just hype?”
Partly, and the data says so plainly.
Gartner expects more than 40% of agentic AI projects to be cancelled by the end of 2027, citing escalating costs, unclear business value and inadequate risk controls. MIT’s Project NANDA study of over 300 generative AI initiatives found most showed no measurable six-month return.
But “40% cancelled” also means a majority are not. The technology works. What fails is the commissioning — vague goals, no measurement, no governance, no cost model, and data that was not ready.
The useful framing: agentic AI is not magic and it is not a scam. It is a capable, expensive, failure-prone tool that pays off when pointed at a well-chosen problem and managed properly.
Where the term came from, and why it matters commercially
“Agentic” entered general business vocabulary during 2024–2025, as models became reliable enough to use tools in sequence rather than only produce text. Before that, “AI” in a business context usually meant a chatbot or a classifier.
Why the distinction is commercially important: the word is now attached to products that are not agentic at all. A scripted workflow with a language model doing one step in the middle is automation with an AI component — useful, cheaper, more reliable, and not an agent.
How to check what you are being sold, regardless of the label:
| Ask | Agent | Not an agent |
|---|---|---|
| “Does it decide its own next step?” | Yes | Follows a defined sequence |
| “How many model calls per task?” | Several, varying | Zero, or exactly one |
| “What happens with unexpected input?” | Adapts or escalates | Fails or misreads |
| “Can it act without approval per step?” | Yes, within boundaries | No |
Neither answer is wrong. Automation with an AI step is frequently the better buy. What matters is not paying agent prices for it. Full comparison here.
How to tell if you have a candidate process
Five questions. Three or more yes and it is worth investigating.
- Does it happen often? Daily or many times a week. Low-volume processes do not repay a build.
- Does it involve reading unstructured information? Emails, documents, notes, varied formats.
- Does it require judgement, but not expertise? The kind a trained person makes in seconds, not one needing a professional qualification.
- Does it span multiple systems? Looking something up in one place to decide what to do in another.
- Is a human doing it now, and could you measure how long it takes? If you cannot measure it today, you cannot prove improvement tomorrow.
What happens inside one, step by step
Following a single task through, so the abstraction becomes concrete.
The trigger. An invoice arrives in a monitored inbox. Something — a scheduled check, a webhook, a file landing — starts the agent.
Context assembly. The agent is given its goal, its available tools, any relevant policy, and the item to work on. This is the part that costs money: everything passed in is charged for, which is why a narrow, purpose-built data view is cheaper as well as safer.
First decision. The model decides what to do first. Usually: read the document.
Tool call. It calls the document-reading tool and gets back text and structure.
Second decision. Now it has the content. It identifies the supplier, the total and the PO reference, and decides it needs to check the purchase order.
Tool call. It queries your system for that PO.
Third decision. The quantity matches; the price is 4% higher. It checks the tolerance policy, finds the threshold is 2%, and concludes this needs a human.
Action. It writes an escalation with the specific discrepancy and the evidence, and stops.
That is seven steps and roughly four model calls for one invoice. Multiply by volume and you have the running cost. Add a retry when a document is unreadable and it is six. This is why the cost model matters before you commit — and why an agent with no step limit can produce a surprising bill.
What a production agent needs around it
The model is perhaps a fifth of the work. The rest is what makes it survivable.
An audit log of every action. What it did, why, what it read, what it changed. Without this, an unexpected action is unexplainable, and unexplainable actions get systems switched off.
Authority boundaries, enforced in code. Not instructions asking it not to do something — actual limits on what the tools permit. An agent that cannot technically issue a payment will not issue one, whatever it concludes.
Confidence thresholds. Below a set certainty, escalate rather than act. This is how you capture the saving on the clear cases without carrying risk on the ambiguous ones.
Step and spend caps. Hard ceilings per task. An agent that loops is an agent generating charges.
An evaluation suite. A set of known cases with known right answers, re-run on a schedule. Model providers update models; your data shifts. Without a suite, degradation is silent.
A kill switch a non-technical person can operate. If the only person who can stop it is the developer who built it, you do not have a control.
Monitoring and alerting. Exception rate, cost per task, latency. Numbers someone looks at weekly.
Frequently asked questions
What is an agentic AI system in simple terms?
Software given a goal rather than instructions, which decides its own steps to reach it. It has four parts: a goal, tools it can use, a loop of deciding and acting, and boundaries limiting what it may do.
What is the difference between agentic AI and a chatbot?
A chatbot responds to a person with text. An agent acts on systems — reading databases, calling APIs, sending messages, updating records. A chatbot that is wrong gives a bad answer; an agent that is wrong takes a bad action.
Is agentic AI the same as automation?
No. Automation follows a fixed script and breaks when reality differs from it. An agent works out its own route and adapts. Automation is cheaper and more reliable when the process never varies — which is more often than vendors suggest.
Do agentic AI systems need supervision?
Yes. They need boundaries on what they may do, audit logging of actions taken, confidence thresholds that escalate uncertain cases, and ongoing measurement because behaviour drifts as models change.
How much does an agentic AI system cost?
A feasibility sprint runs £6,000–£12,000. A single production agent runs £18,000–£45,000. There is also a model usage cost that scales with volume and is frequently left out of quotes. Full costs →
Can agentic AI replace staff?
Usually it removes a portion of a role rather than a whole one — the repetitive, judgement-light part. The exceptions still need a person, and someone has to own and monitor the agent. Businesses that plan for net-zero headcount change and better throughput tend to be less disappointed.
What happens when the AI gets it wrong?
In a well-built system: the action is logged, the uncertain case is routed to a human, authority boundaries limit the damage, and a kill switch exists. In a badly built one, you find out later.
Written by Jas Singh, Founder. Last updated 8 October 2026.
Figures from Gartner’s forecast on agentic AI project cancellation and MIT Project NANDA (August 2025). These measure different things and are cited as directional.
