When not to use an agent

We sell agent infrastructure, so read this with that in mind, and then believe us anyway: most workflows should not be agents. An agent is a loop that decides its own next step. That autonomy is the product, and it's also the cost: non-determinism, multiplied tokens, and a testing surface that grows with every tool you hand it. If a workflow doesn't need the autonomy, you're paying agent prices for pipeline work.

The one-question framework

Ask: can a competent operator write down the steps in advance? If yes, build a pipeline: a fixed sequence of LLM calls and code, each step testable on its own. Extract, classify, summarize, draft-then-template: all pipelines. The agent loop earns its keep only when the path genuinely varies per case, when step four depends on what step three discovered and you can't list the branches ahead of time. Debugging incident root-causes, multi-source research, open-ended operations triage: agent territory.

Four disqualifiers

Even when the path varies, these four conditions should stop you:

• 1. Irreversible actions without a human gate. If the workflow's write-path can't be undone (payments, deletions, external messages at scale) and you can't afford an approval step, the failure math never closes. Guardrails reduce risk; they don't make an unreviewable action reviewable.
• 2. A hard latency budget. Agent loops are slow by construction: plan, call, observe, repeat. If your user is waiting more than a few seconds, an agent in the request path will lose to a pipeline every time.
• 3. No eval story. If you can't say what "correct" looks like well enough to grade it, you can't ship an autonomous loop that's supposed to achieve it. Build the pipeline first; let its outputs teach you the rubric.
• 4. Volume without value asymmetry. Agents make sense when a good outcome is worth many times the run cost. A million low-stakes runs a month is pipeline economics, not agent economics.

The cost math nobody shows you

A single-call pipeline step costs one prompt and one completion. An agent run averages 6 to 12 model calls once you count planning, tool-result digestion, and self-checks. The context window re-sends the growing transcript on every call, so token cost compounds roughly quadratically with loop length. Rule of thumb from our own metering: an agent run costs 15 to 40 times the single LLM call teams budget for when they prototype. If the workflow runs 100k times a month, that multiplier is the difference between a rounding error and a line item your CFO circles.

None of this is an argument against agents. It's an argument for spending agent budget where autonomy pays, and for having the honesty, before you build, to notice when it doesn't. Half the teams that come to us leave with a pipeline design and a promise to come back when the branching gets real. They're our favorite future customers.