Agentic AI — systems that plan, use tools and take multi-step actions on their own — is the most exciting and most over-applied idea in the field right now. Used well, an agent removes genuine drudgery. Used because it is fashionable, it adds fragility, cost and risk to problems a simple pipeline would have solved more reliably. Knowing when not to reach for an agent is as valuable as knowing how to build one.
What an agent actually is
An agent is more than a chatbot. A chatbot answers; an agent decides what to do next, calls tools, observes the result and continues until it reaches a goal. That autonomy is exactly what makes it powerful and exactly what makes it risky. Every step is a place where it can go wrong, and errors compound across a chain of decisions taken at machine speed.
When a pipeline wins
If a task is well-defined and follows the same steps every time, you do not need an agent — you need a pipeline. Extracting fields from invoices, transforming data on a schedule, classifying incoming documents: these have a known shape. A deterministic pipeline is cheaper to build, faster to run, trivial to test and far easier to trust. Wrapping such a task in an autonomous agent adds a decision-making layer that can only introduce new ways to fail.
The test is simple. If you can draw the flowchart, build the flowchart. Reserve agents for the cases where you genuinely cannot enumerate the steps in advance because they depend on what the agent discovers along the way.
When an agent earns its place
Agents shine when a task requires genuine branching that cannot be scripted: researching a question across many sources where the next search depends on what the last one returned; triaging a varied inbox where each item needs different handling; reconciling records where the exceptions are unpredictable. Here the flexibility of an agent is not a liability but the whole point.
Even then, the engineering that matters is the guardrails, not the autonomy. A good agent knows exactly what it is allowed to touch, requires human approval before anything consequential, logs every action, and has a hard stop when it is out of its depth. The autonomy is bounded on every side.
The hidden costs
Agents are more expensive to run, because multi-step reasoning means many model calls per task. They are harder to test, because their behaviour is non-deterministic. They are harder to debug, because a failure three steps deep can have its root cause much earlier. And they carry more risk, because an autonomous system taking wrong actions confidently, at speed, can do real damage before anyone notices. None of these are reasons to avoid agents — but they are reasons to be honest about the trade before committing.
A simple decision rule
Ask three questions. Can you specify the steps in advance? If yes, build a pipeline. Does the task need to adapt based on what it finds? If yes, an agent may be justified. Can you bound and reverse its actions, with a human approving anything that matters? If not, do not deploy it until you can. Most tasks that people reach for agents to solve fail the first question — they were pipelines all along.
The middle path: constrained agents
The choice is not always binary between a rigid pipeline and a fully autonomous agent. Some of the most reliable systems sit in between: a mostly-scripted flow with one or two points where a model makes a bounded judgement. The overall path is predictable and testable, but the system can still handle the variation that made a pure pipeline impossible. This constrained design captures much of the flexibility of an agent while keeping most of the reliability of a pipeline — often the best of both worlds.
Thinking in these terms — how much autonomy does this specific step actually need — leads to better systems than reaching for a full agent by default. Most steps need none. A few need a little. Very few need the model to be genuinely in charge.
Evaluation is what makes agents safe
If you do build an agent, the single practice that separates a dependable one from a liability is evaluation. A fixed set of representative tasks, scored automatically before and after every change, tells you whether an "improvement" actually improved anything or quietly broke a category of cases. Without this, an agent's non-determinism means you are shipping changes on faith. With it, you can iterate with the same confidence a software team gets from a test suite.
The honest recommendation
We build agentic systems, and we frequently talk clients out of them. The goal is never to use the most impressive technology; it is to solve the problem in the way that is most reliable, cheapest to maintain and easiest to trust. Sometimes that is an agent. Often it is a constrained flow with a little judgement at the edges. More often than the hype suggests, it is a plain, well-built pipeline — and recognising the difference is where real engineering judgement shows.