The fastest-growing line in AI budgets today is the word "agent." A workflow that a year ago was called automation gets a new label — and with it a higher token bill and a thinner audit trail. Our thesis is simple: most of what's sold as "agentic" is a deterministic pipeline in a pricier, harder-to-audit costume. The question "when to deploy an AI agent" increasingly has the wrong default answer — "always" — and it's the operator who has to correct it.
This text doesn't explain what an agent is. It's a checklist for the person who has to approve the budget and sign off on the risk — four conditions an agent has to meet at once for its non-determinism to be worth the price, and the signals that you're better off staying with a script.
The boundary is architectural, not marketing
The cleanest definition we know comes from Anthropic's engineering note "Building effective agents": a workflow is a system where the model and tools are orchestrated through predefined code paths; an agent is a system where, at runtime, the model itself decides its own process and which tools to use. Every other difference — cost, predictability, auditability — follows from that single choice: who holds the control flow. With a script, you hold it. With an agent, you hand it to the model.
There's a practical test for this, one we owe to practitioners in the field: can you draw the flowchart of the task before the model runs? If yes — you have a workflow, and an agent adds nothing but a bill. If the flowchart depends on what the model discovers along the way — then the conversation about an agent begins.
Four conditions an agent has to meet at once
An agent earns its non-determinism only when all four are true at the same time. Missing even one is a signal you're building a pricier script.
1. An open-ended task space. The number and order of steps can't be fixed in advance, because they depend on what the system encounters along the way. Classifying email by fixed rules or generating a quote from a template is not an open-ended space — it's a pipeline with branches. Debugging, where you have to gather context, form a hypothesis and test it, is.
2. Genuine tool orchestration. The value comes from the model choosing, combining and retrying tool calls on the fly, in an order you didn't know beforehand. If you always call the same three APIs in the same order, you don't need a model that "decides" — you need a function.
3. A human in the loop who genuinely decides. Non-determinism makes sense when there's a point where a human brings judgment that can't be coded into a rule — approving, correcting, rejecting with context. If "human in the loop" comes down to clicking "OK," it isn't oversight but theater, and the agent has handed you nothing but a higher cost.
4. A tolerable cost of error. This is the condition that most often sinks a project. An agent's errors compound: across ten steps, each correct 99 percent of the time, the whole run succeeds in fewer than nine cases out of ten. Where a mistake costs a minute of work, that distribution is bearable. Where it costs a client, a transaction or compliance, it isn't — and that's the moment you return to deterministic boundaries. The same error-cost logic underlies the NIST AI Risk Management Framework: the more expensive the mistake, the less room for uncontrolled latitude.
When to say "no" — and what to do instead
The rule repeated by both model vendors and the practitioners building these systems is: start with the simplest possible solution and add complexity only when the task genuinely demands it. In practice that comes down to three of the most common "no"s:
- An "agent" for a process you can draw. If the flow is fixed, build a workflow. You get a predictable token cost, every path testable, and a log that survives an audit — everything an agent, by definition, doesn't give you for free.
- An agent because "that's how it's done now." Non-determinism isn't a premium feature; it's a trade-off — you pay in latency, cost and harder debugging for a flexibility you may not need.
- An agent with no boundaries and no owner. If you can't say what it may do on its own, what it may only propose, and what it mustn't touch — you're not ready to run it, no matter how well it shows in a demo.
The most durable systems we see in production are hybrids: a deterministic skeleton that keeps cost and audit in hand, with islands of agent latitude exactly where the four conditions above hold — and nowhere else.
Why it matters
Private Equity
For a fund, "agentic" in a company's investment thesis is a question about cost and risk, not modernity. If the margin is meant to grow thanks to agents, it's worth asking which processes genuinely require non-determinism and which are overpaying for a script in disguise — because that's a difference in the inference bill and in the auditability you only see after the transaction. It's the same risk register we described in governed agents in the enterprise, only read from the side of "was this pattern needed at all."
Enterprise
For a large organization, the biggest cost isn't the agent itself but an agent placed where a workflow would have done — because it adds unpredictability to a system that has to pass a risk review anyway. Before the team starts building, it's worth running the project through the four conditions and writing down the decision: why an agent here, and not a pipeline. That one paragraph of justification is cheaper than six months of maintaining a non-determinism no one needed.
SMB / mid-market
For a mid-sized company, the good news is this: most of the fastest-returning automations are a workflow, not an agent — and that's exactly why they're cheap, predictable and deployable without an AI department. Don't buy an "agent" because that's what the vendor's offer calls it. Buy a solution to the problem, and let the nature of the task — not the label — decide whether non-determinism is needed.
One step you can take this week
Take one process someone wants to "turn into an agent," and try to draw its flowchart on a single page before you run anything. If you managed it — you have a workflow, and you've just saved yourself the bill for non-determinism. If the chart falls apart at the first "it depends what the system finds" — walk it through the four conditions and check whether all are met, not just the one that sounds the most interesting.
Describe your case
If you have a process someone is calling "let's make it an agent," and you're not sure it's the right pattern, bring that one process and its flowchart. We start from something concrete: we settle where an agent earns its cost and where a script is enough — and how to wire it into our services. Describe your case: mailto:[email protected]?subject=Rozmowa%20z%20Aurora%20AI.