“Agentic” is now the word every AI vendor needs somewhere on its homepage. It shows up in pitch decks next to “autonomous” and “reasoning”, usually without a definition attached. That’s normally the moment a useful term starts dissolving into marketing fog, so it’s worth pinning down before the fog thickens.
The short version: agentic AI describes software that gets handed a goal and works out the steps for itself, using tools, checking its own progress, and deciding when the job is finished. A conventional AI feature answers a question. An agentic one goes and does something about it.
That’s the whole idea. The interesting part is what it takes to make it real.
Where the word comes from
“Agentic” is built from agency, the capacity to act on your own judgement. In law and philosophy, an agent is something that can make choices and be held responsible for them. Software has historically had none of that. It ran the branches a developer wrote, in the order the developer chose, and stopped exactly where it was told to stop.
An agentic system keeps the goal and throws away the script. You tell it to reconcile a month of invoices, and it decides whether that means reading PDFs, querying the accounting API, or emailing a supplier to ask what a line item actually was. Nobody wrote that sequence in advance.
The four traits that separate an agent from a chatbot
The word gets applied loosely, but there’s a reasonably stable core. A system is doing agentic work when most of these hold:
- It receives an outcome, not a procedure. “Get these five quotes compared and ranked” rather than “summarise this document”.
- It picks its own tools. Web search, a database read, a calendar write, a payment API, a browser session. The choice is made at runtime based on what the task needs.
- It holds state across steps and inspects its own output. If a search returns nothing useful, it reformulates. If a form rejects its input, it reads the error and tries again.
- It decides when to stop. Success, failure, or a handoff to a human. The termination condition isn’t hardcoded per scenario.
Drop the third trait and you have a pipeline with a language model bolted on. Drop the first and you have a chatbot with extra buttons.
A concrete example beats a definition
Ask a standard chatbot to find three packaging suppliers in the Midlands that can handle a 50,000-unit run. You’ll get a plausible list, possibly with two invented companies, and you’ll do the verifying yourself.
An agent takes the same request and opens real pages, checks whether each supplier lists that volume, notes which ones publish a lead time, drops the two that turn out to be distributors rather than manufacturers, and comes back with a shortlist plus the reasoning behind each ranking. If you’ve authorised it, it drafts the enquiry emails and leaves them in your outbox for approval.
That last detail matters more than it sounds. Someone still has to read the drafts. The work moved; the accountability didn’t.
Inside the loop: plan, act, look, adjust
Underneath, most agents run a variation of the same cycle. Draft a plan. Take one step. Observe what came back. Revise the plan. Repeat until done or stuck. The pattern is unglamorous and it explains both the capability and the failure modes. Understanding what it actually means when software starts doing the work comes down to watching that loop in action rather than reading the spec sheet.
Why today’s agents are short, not long
Reliability compounds against you. A step that succeeds 95% of the time sounds solid until you chain ten of them: 0.95 multiplied by itself ten times is roughly 60%. Chain thirty steps and you’re below a coin flip. This is why serious deployments keep agents to three or six actions with a human checkpoint in between, and why demos that run for forty steps without supervision tend to be exactly that, demos.
Where the label gets stretched
A marketing team refreshes its homepage and suddenly every feature is agentic. Three tests cut through most of it.
Ask whether the system can choose a different path on Tuesday than it chose on Monday for the same input. If the sequence is fixed and the model only fills in a field, that’s an LLM-assisted workflow, which is genuinely useful but not the same thing. Ask what happens when a tool call fails. A fixed pipeline breaks; an agent routes around it. And ask who reviews the output before it touches anything real, because a system with write access and no approval gate isn’t autonomous, it’s unsupervised.
None of this is an argument against workflow automation. Deterministic beats clever when the task is deterministic. The error is using agentic as a synonym for good.
Agents need keys, and that’s the awkward part
To act, an agent needs permission to act. That means API credentials, browser sessions, access to a CRM, sometimes a corporate card. Every one of those is a surface. Security teams now ask questions that didn’t exist for chatbots: which actions can this thing take without a human, where’s the audit trail, and how do we revoke access in ninety seconds if it goes wrong.
There’s a quieter obstacle too. A lot of the web is built to detect and block automated traffic, so agents that need to book, buy, or file on a real website run into captchas and rate limits designed for bots. The friction of getting websites to let AI agents in is turning into a policy argument about identity and consent, not just an engineering problem.
Inside the enterprise, the pattern that works is narrow scope plus deep integration. IT service desks are a decent example: platforms built to resolve tickets end to end rather than just summarise them succeed because the action space is small, the tools are internal, and success is measurable per ticket.
Four questions to ask before you buy an “agentic” product
- What can it do without a human approving it, and is that list written down anywhere?
- What does the run log look like, and can I replay a failed run step by step?
- Which systems does it hold credentials for, and who rotates them?
- When it gets a step wrong, what’s the blast radius and how fast is rollback?
Vendors with a real product answer these in a paragraph. Vendors with a slide deck answer them in adjectives.
What it looks like when the plumbing catches up
The direction of travel is toward agents that persist, know your context, and run on hardware designed with them in mind. The pitch for personal AI assistants at home assumes exactly this: something that books, schedules, and follows up without being re-prompted every time. Meanwhile the machines themselves are shifting, with AI-friendly hardware and Windows changes aimed at running models closer to the user rather than in a distant data centre.
Those pieces matter because latency and trust are the two things that kill agent adoption. An assistant that takes forty seconds and gets it wrong twice is a novelty. One that takes two seconds and is right nine times out of ten gets used every day.
The real shift is in what we judge
For thirty years, software quality meant output quality. Did the report generate, did the page load, did the number match. Agentic systems move the question to judgement quality: did it choose the right tool, did it notice the anomaly, did it stop when it should have.
That’s harder to test and much harder to fake in a demo. It also means the useful skill for the next few years isn’t prompt writing. It’s specifying constraints, defining what “done” means precisely enough that a machine can recognise it, and designing the checkpoint where a human looks before the irreversible thing happens. Teams that get that right will find agents quietly absorbing the tedious middle of their workflows. Teams that skip it will get an expensive lesson in what happens when software has initiative and nobody has written down the boundaries.