What is an agentic workflow?
An agentic workflow is a defined process in which one or more AI agents carry out steps. The term covers two quite different things, and conflating them is the source of most disappointment with the category.
In the first, the sequence lives in code. You wrote the steps; an agent does the thinking inside each one. This is deterministic, replayable and debuggable, and you still get the model's capability where it matters.
In the second, the model decides the sequence. Given a goal and tools, it works out what to do next. This handles problems whose shape you could not know in advance, and it costs you the ability to reason about what the system will do.
Anthropic's engineering write-up on building effective agents draws exactly this line and recommends the simplest thing that works, which in practice means the first option far more often than teams expect.
The patterns worth knowing
- Chaining. Step output feeds the next step. Use when the decomposition is stable. Cheapest to debug of anything here.
- Routing. A classifier sends work down one of several paths. Use when input types differ enough that one prompt serving all of them serves none of them well.
- Parallel fan-out. Independent work runs simultaneously, results are combined. The largest wall-clock win available, and the pattern most often implemented in a way that throws the win away.
- Evaluator loops. One agent produces, another critiques, repeat until a bar is met. Effective specifically when the critic has a different objective from the producer. A critic asked to agree will agree.
- Orchestrator and workers. A coordinating agent decomposes and delegates. The most capable and the least predictable, because the decomposition itself is now a model output.
The barrier problem, which costs more than people think
Fan-out is usually written as: run everything in stage one, wait for all of it, run everything in stage two. That wait is a barrier, and it costs the difference between the slowest branch and the fastest. If one branch takes three times as long as another, the fast branches sit idle for the difference, and you paid for parallelism you did not get.
The alternative is to pipeline: let each item flow through all stages independently, so item A can be in stage three while item B is still in stage one. Wall-clock becomes the slowest single chain rather than the sum of the slowest-per-stage. A barrier is only genuinely required when a stage needs cross-item context, for instance deduplicating across every result before expensive downstream work. "I need to reshape the data first" is not a reason for a barrier; that transformation belongs inside a stage.
Where these systems actually fail
- Silent empty returns. A stage produces nothing, the run completes, and the output is confidently empty. Log what each stage actually returned, not that it finished.
- Compounding error. Five steps at 95% each is 77% end to end. Long chains need verification between steps, not just at the end.
- Critics that agree. An evaluator sharing the producer's framing rubber-stamps. Give it a different objective, and prefer asking it to refute rather than to assess.
- Unbounded loops. Any loop needs a termination condition that is not the model's opinion of whether it is finished.
- Cost invisibility. Fan-out multiplies spend quietly. A workflow that silently caps coverage should say so, because a truncated run reads as a complete one.
A default worth adopting
Start with the sequence written in code and agents inside the steps. Add agent-decided control flow only where you can point at a specific decision that genuinely cannot be made in advance. This is a boring recommendation and it is the one that has held up: the systems we still run unattended are the deterministic ones, and the ones we rewrote were the ones where the model chose the path.
Related reading
For the discipline of operating these, see agentic engineering. For whether an agent is warranted at all, when not to use AI agents and AI agents versus automation, which is the same question asked from the automation side. The return-on-investment case is at agentic AI ROI, and the security surface at agentic AI security. A worked example rather than a position: our spec-driven development run.