The word is doing no work
“Agentic” has become the adjective that means “we used a language model somewhere”. It appears on landing pages next to words like “autonomous” and “self-improving”, and it carries no information you can act on. That matters, because the thing it is supposed to describe — whether a system decides its own next step — is the single most important fact about how it will behave in production.
Here is the distinction worth keeping.
A workflow with a model in it. You decided the steps. The model does one bounded job inside a sequence you wrote: classify this, extract that, draft this reply. Run it twice on the same input and you get the same path, because the path was never the model’s to choose.
A system that chooses its own path. You supplied a goal and a set of available actions. At runtime it decides which action to take next, looks at the result, and decides again. Run it twice on the same input and the path can differ, because the choice is made per run.
Both are legitimate engineering. Only the second is agentic. The difference is not vocabulary policing — it decides how you test the thing, how you cost it, and the shape of its failures.
A ten-minute test
Ask three questions of whoever is selling it. If the first two come back “no”, you are buying a workflow, which is fine — you just want to be paying workflow money for it.
Can it take an action you did not enumerate in advance? Not “does it use tools” — every integration uses tools. Ask whether the set of actions is fixed at build time, or whether the system selects among them per run. A pipeline that calls four APIs in order is not choosing.
Does the path change between runs on identical input? This is the observable version of the first question. If the answer is no, the model is a component, not a decision-maker — and you can test the whole thing deterministically, which is a gift.
Is there a step limit, and who set it? Every competent agentic system has a ceiling on how long it can keep going before it stops and asks. If nobody can tell you what happens when the limit is hit, the answer is usually “it keeps spending”.
That third question is the one that separates a product from a demo. Unattributed failure is the common thread in the automations that stall, which is why the workflows I actually rebuild each state their setup time and what they do not do.
Why the distinction changes your budget
A workflow with a model in it has a bounded cost per run. You know the steps, so you know the calls, so you know the tokens. Testing is deterministic: the same input produces the same path, and a regression is a bug you can reproduce.
An agentic system has a cost distribution, not a cost. The number of steps varies, so the spend varies, and a bad run can be expensive in a way a pipeline never is. Testing has to be statistical — you are measuring a rate, not asserting an outcome. And the failure mode is qualitatively different: a pipeline fails by breaking, while an agent fails by confidently choosing the wrong action and then reporting success.
Neither is better. They are different instruments, and using the wrong one is how you end up with an expensive pipeline or a cheap agent that cannot be trusted with anything that matters.
Where agentic is the wrong choice
Most of the automation worth doing in a normal business is not agentic, and pushing an agent at it makes things worse. If the process is stable, high-frequency, and the steps are known — invoice matching, lead routing, a weekly report, a review sweep — a deterministic workflow is faster, cheaper, and testable. Wrapping it in an agent buys you variance you did not want.
Agentic earns its cost in a narrower band: the goal is clear, the path genuinely is not, the inputs vary enough that enumerating cases is hopeless, and a wrong action is recoverable. Research and triage sit there. Reconciliation usually does not.
The workflows in the library are deliberately the deterministic kind, and each one states its setup time and what it does not do — because the honest boundary of a tool is more useful than its feature list. If you want the agentic end of this, that is a different conversation, and the courses cover where the line sits and how to test on either side of it.
The honest position
Nobody can currently promise you an autonomous system that reliably improves itself. What can be promised is narrower and more useful: a process that runs unattended, reports when something changed, and fails in a way you can see. Whether a model chooses the steps inside it is an implementation detail — an important one, but a detail.
Ask the three questions. Write down the answers. If the answers are vague, the architecture is vague, and the budget will be too.