Reef TRHThe log scrolls for a while before anything useful happens. A planner agent reads the customer's question and splits it into four sub-tasks. A retrieval agent goes hunting for a contract clause. A third agent — a critic, whose entire job is to doubt the second — reads what came back and objects: wrong version of the contract. The retriever tries again. Only then, six model calls deep, does a drafting agent produce the two-sentence reply the customer will ever see.
That reply was good. It quoted the right clause, in the right tone, and a human approved it in seconds. The multi-agent system worked. The harder question — the one almost nobody asks before building — is whether it needed to be a multi-agent system at all.
"Agentic" is the most fashionable idea in AI right now, and the most misapplied. Strip away the word and most of these systems are a fixed sequence of steps, run in the same order every time, dressed up in the language of autonomy. Knowing which one you are actually building is close to the whole game.
What the word is hiding
A real agent decides its own next move. It plans, acts, looks at the result, and re-plans when the result surprises it. A pipeline does no such thing: it runs step one, then step two, then step three, identically on every request, whatever comes back. Both can involve several model calls. Only one of them is making decisions.
The trace above looked autonomous because it had named "agents" in it. But watch what actually happened, in order: it retrieved, it checked, it re-retrieved, it drafted, it validated. Four of those steps run in that order every single time. That is a flowchart, not a decision.
Where the agents earned their keep
There was exactly one moment in the run that justified the whole apparatus: the critic catching the wrong version of the contract. A single model call, however well prompted, would have taken the first clause it found and written a fluent, confident, subtly wrong reply — and the human, seeing a tidy answer, would have approved it. The second agent existed to distrust the first, and that distrust is what saved the answer.
That is the real signal. Agentic structure earns its complexity in a narrow set of conditions, and it is worth being honest about how narrow:
- The task genuinely branches — the next step depends on what the last one found, and you cannot draw the path in advance.
- A wrong middle step is both costly and catchable — worth spending a whole extra call to doubt it.
- The work is open-ended — research, investigation, triage — rather than a fixed transformation from one known shape to another.
Where a pipeline would have won
Now the uncomfortable half. Take the same run and count: only the re-retrieval was a genuine decision. The other five calls happened in the order they always happen. A plain, deterministic pipeline — retrieve, validate the clause, draft, check against policy — would have produced the same reply with fewer calls, a fraction of the latency, and one enormous advantage: it would have done it the same way every time.
Autonomy is not free. You pay in non-determinism — the same input can wander down a different path on Tuesday. You pay in latency, because each step waits on the one before. You pay with a wider failure surface: more agents, more prompts, more places to break. And you pay every time you debug, because the artifact is a rambling transcript rather than a stack trace. You pay all of it whether or not the task ever used the flexibility you bought.
This is the same trap that fills the POC graveyard from a different direction: reaching for the most capable-sounding architecture instead of the one the problem needs. And because every agent is another model call, the choice quietly compounds the real running cost — five calls where one would do, forever.
So when do you actually need one?
Start with the boring pipeline. Draw the steps. If you can draw them, build them — a flowchart you can test, cache and reason about beats an agent you have to interrogate. Where a middle step can be wrong in a way that matters, add one adversarial check, the critic that saved the reply above. Reserve true agentic autonomy for the last mile: the tasks where the path honestly cannot be known until the model is standing in the middle of them. That decision — pipeline, checked pipeline, or genuine agent — is exactly what a short AI readiness assessment is meant to settle before a line of orchestration is written.
Common questions
What's the difference between an AI agent and a pipeline? A pipeline runs fixed steps in the same order every time; an agent decides its own next step from what it observes, and can re-plan. Most "agentic" systems are pipelines with extra latency.
Do I need a multi-agent system? Usually not to start. If you can draw the sequence in advance, a deterministic pipeline is cheaper, faster and easier to trust. Reach for agents when the path genuinely cannot be predefined.
What does agentic cost that a pipeline doesn't? Non-determinism, latency, a larger failure surface, and harder debugging — worth it when the task needs live decisions, wasteful when it doesn't.
The best reason to build an agent is that you sat down to draw the flowchart and found you couldn't — the task refused to hold still. The worst reason is that agents are what everyone is building this quarter. Most teams have the second reason and have quietly convinced themselves it is the first.