Everyone sells agents now. Most of what you need is not an agent.

Open LinkedIn, a vendor site, or a trend report this year and the word is everywhere: agents. Autonomous agents, agent workforces, digital employees. The pitch is that software will now decide what to do on its own, and that anything less is last year's automation. It's a genuinely exciting idea. It's also being stapled onto products that are nothing of the sort, and sold for problems it makes worse.

Here's the distinction the marketing skips. An agent is software that chooses its own next step at runtime: it looks at the situation, decides what to do, does it, looks again. A pipeline is software where you chose the steps in advance: fetch this, extract that, check it against the ledger, write the result. Both can use AI. The difference is who decides the route, the model in the moment, or you at design time.

Why the difference matters more than the demo

When the route is decided at runtime, every run is a new route. That's the property you're buying, and it cuts both ways. It's what makes agents genuinely useful for open-ended work, and it's exactly what you don't want in a process that must produce the same correct result every day. A pipeline that failed yesterday can be replayed and fixed, because the steps are the steps. An agent that failed yesterday may not even take the same path today.

• Reliability: a pipeline's failure modes are enumerable, so you can test them. An agent's failure modes include routes nobody has seen yet.
• Cost: agents burn model calls deciding what to do. A pipeline spends one model call doing the one thing rules can't, reading a messy PDF, classifying an email, and rules handle the rest.
• Debuggability: when a pipeline breaks, the log tells you which step. When an agent breaks, you're reading a transcript of its reasoning trying to figure out what it was thinking.

Three questions that tell you which one you need

• Is the path known in advance? If a competent person does this task the same way every time, the path is known. Build a pipeline. Autonomy adds variance to a task that wanted none.
• Is it the input that's messy, or the process? Invoices in fourteen layouts, replies in free text, scanned forms: that's messy input, and it needs one model step inside a fixed process, not a free-roaming agent.
• What does a wrong action cost? If the system writes to your ledger, emails your customers, or moves money, you want deterministic steps with a checkpoint, not a decision-maker improvising under load.

Score your task against those three and most back-office work, order entry, reconciliation, reporting, follow-ups, invoice capture, lands firmly on the pipeline side. The path is known, the input is the only messy part, and errors are expensive. That's not a knock on agents. It's just what the work is.

Where an agent genuinely earns its place

Real agent territory exists: tasks where the route can't be scripted because it depends on what turns up. Researching a prospect across sources. Triaging a support queue where each ticket needs different digging before it's routed. First-pass investigation of why numbers don't match, before a person decides. The pattern is consistent: agents for the open-ended read-and-recommend work, pipelines for the do-it-the-same-way-every-time work, and a human checkpoint wherever an action has a real cost.

Ask the vendor one question: what exactly happens when it's wrong? A confident answer describes a checkpoint. A vague one describes your new problem.

The uncomfortable truth for everyone selling agent workforces is that the highest-value automation in most businesses is boring: the same steps, every day, without a person watching. That was true before agents and it's true now. Rules first, a model where it earns its place, and autonomy only where the route is genuinely unknown. Buy the property you need, not the word of the year.