Agentic workflows & agent design patterns
Most agentic systems aren't one big autonomous loop — they're composable patterns. Learn the six core agent design patterns, when each one wins, and how to decide between a predictable workflow and a fully autonomous agent.
- 11 min read
- Intermediate
- Updated 2026
Agentic workflows are reusable patterns for orchestrating language models, tools, and control flow to get a job done. The single most useful idea in this whole space is that workflows and agents are two ends of a spectrum, not two different technologies. In a workflow, a human designs the path through the system ahead of time — the steps and their order are predefined in code. In an autonomous agent, the model itself decides the path dynamically at runtime, choosing which tools to call and how many times to loop.
Why does the distinction matter? Because autonomy is not free. Every decision you hand to the model adds latency, token cost, and variance. A well-designed system pushes as much as possible into predictable workflow structure and reserves true agentic decision-making for the moments that genuinely need it. The best engineers reach for the simplest pattern that solves the problem — and only add autonomy when the task is open-ended enough to justify it.
This guide walks through the six agent design patterns that show up again and again in production: prompt chaining, routing, parallelization, orchestrator-workers, evaluator-optimizer, and reflection. Together they cover the vast majority of real LLM agent systems, and they compose cleanly into larger multi-agent systems.
The workflow-to-agent spectrum
Think of control flow as a dial, not a switch. The further right you turn it, the more decisions you delegate to the model.
Rule of thumb
Move right on the spectrum only when you can articulate a concrete task that the previous, more predictable pattern cannot handle. If you can write the steps down in advance, you probably do not need an autonomous agent — you need a workflow.
Core agentic workflow patterns
Six patterns cover almost every agentic system you'll build. Each is simple on its own; the power comes from composing them.
Prompt chaining
Decompose a task into a fixed sequence of LLM calls, where each step's output feeds the next. Add programmatic gates between steps to validate output before continuing — e.g. outline → draft → polish.
Routing
Classify the input, then dispatch it to a specialized prompt, model, or tool. Lets you send easy queries to a cheap model and hard ones to a stronger one, keeping each path focused and accurate.
Parallelization
Run independent subtasks concurrently and aggregate the results. Two flavors: sectioning (split work into parts) and voting (run the same task multiple times for a consensus or guardrail check).
Orchestrator-workers
A lead model breaks a goal into subtasks at runtime and delegates each to a worker. Unlike parallelization, the subtasks aren't known in advance — the orchestrator decides them based on the input.
Evaluator-optimizer
One model generates a candidate while a second evaluates it against criteria and returns feedback. The loop repeats until the output passes — ideal when quality has clear, checkable standards.
Reflection
The model critiques and revises its own output before returning it. A lightweight, single-model cousin of evaluator-optimizer that catches obvious errors and improves reasoning quality.
Patterns compose
These aren't mutually exclusive. A real system might route an incoming request, fan out subtasks with parallelization, then run an evaluator-optimizer loop on the aggregated result. Treat each pattern as a Lego brick, not a whole architecture.
Example: a routing workflow
A classifier inspects the input once, then dispatches it down the cheapest path that can handle it — improving both accuracy and cost.
Routing shines when inputs fall into distinct categories that are better handled separately. By classifying first, you avoid stuffing one mega-prompt with instructions for every case — which both dilutes accuracy and burns tokens. A cheap, fast model often makes a perfectly good router, even when the downstream handlers use a larger model.
Example: the evaluator-optimizer loop
When quality can be judged against explicit criteria, a generate-then-critique loop reliably lifts output quality — at the cost of extra calls.
Cap your loops
Any pattern with a feedback loop — evaluator-optimizer, reflection, or an autonomous agent — needs a hard stopping condition: a maximum number of iterations, a budget ceiling, or a confidence threshold. Without one, a stubborn task can loop indefinitely and quietly run up cost.
Example: orchestrator-workers
When the subtasks can't be known in advance, a lead model decomposes the goal at runtime and delegates to dynamically spawned workers.
Orchestrator
Plans subtasks at runtime
Researcher
Gathers sources
Data worker
Queries the warehouse
Coder
Writes & runs code
Writer
Drafts the answer
The key difference from parallelization is that the subtasks are not predefined. The orchestrator reads the input and decides — at runtime — how to break the work down and how many workers to spawn. That flexibility is exactly why this pattern edges toward the agentic end of the spectrum. For a deeper dive into coordination, delegation, and shared memory, see multi-agent systems.
Workflows vs autonomous agents
Neither is universally better. The right choice depends on how predictable the task is and how much you value adaptability over cost and reproducibility.
| Dimension | Fixed workflow | Autonomous agent |
|---|---|---|
| Control flow | Defined by the developer | Directed by the model |
| Predictability | High | Lower |
| Cost & latency | Low, bounded | Higher, variable |
| Flexibility | Limited to designed paths | Adapts to novel inputs |
| Debugging & reproducibility | ||
| Steps known in advance? | ||
| Best for | Classification, extraction, templated tasks | Open-ended, multi-step problems |
Core patterns
cover most systems
Typical cost
of a loop vs. one call
Stopping rule
every loop needs one
Traceable
log every step
The practical takeaway: don't default to autonomy. An autonomous agent is the most flexible and the most expensive, least predictable option. If the steps are known, a workflow will be cheaper, faster, and far easier to debug. Save the autonomous loop for tasks where the path genuinely cannot be planned in advance — and read how to build AI agents for the implementation mechanics.
Choosing the right pattern
Run through this checklist before reaching for the heaviest tool. Most of the time, a simpler pattern wins.
- Can you write the steps down in advance? — If yes, use prompt chaining — no autonomy needed
- Do inputs fall into distinct categories? — Route them to specialized handlers
- Are subtasks independent of each other? — Parallelize and aggregate the results
- Are subtasks unknown until runtime? — Use orchestrator-workers to decompose dynamically
- Is there a clear quality rubric? — Add an evaluator-optimizer loop
- Does every loop have a stopping condition? — Cap iterations, budget, or confidence
- Could a smaller model handle this step? — Reserve strong models for hard decisions
- Is full autonomy genuinely required? — Only if the path truly can't be planned
Start simple, then escalate
Build the smallest pattern that works, measure it, and add complexity only where the data shows you need it. Many teams find a routed prompt chain outperforms an autonomous agent on real workloads — at a fraction of the cost and with far better observability.
Agentic workflows, answered
Agentic workflows are structured patterns for chaining LLM calls, tools, and routing logic to solve a task. They sit on a spectrum: at one end are fixed workflows where the path through the system is predefined in code, and at the other are autonomous agents that decide their own steps at runtime. Most production systems mix both — a predictable skeleton with agentic decision points where flexibility is genuinely needed.
Go deeper on agent design
Build agentic workflows that ship
Compose routing, chaining, and orchestration into production-grade agents — with tracing on every step. Free to start, no credit card required.