The 7 Agentic Workflow Design Patterns That Matter in 2026

How we picked these seven patterns

There is no canonical list of agentic design patterns, so the honest thing is to say where ours came from. We kept only patterns that appear under a stable name in more than one primary source. Anthropic's engineering post Building Effective AI Agents supplies five workflow patterns plus the autonomous agent. The LangGraph documentation uses the same five names for the same shapes. The Google Agent Development Kit ships three of them as first-class agent types. Andrew Ng's widely cited four patterns overlap with all of it under different labels, so where a pattern has two common names we give both, because people search both. The seventh, the human checkpoint, is here because the OpenAI Agents SDK and LangGraph both ship it as a documented primitive rather than as advice.

• Named in a primary source: it appears under that name in vendor engineering writing or framework docs, not only in a roundup.
• Named twice: if practitioners call it two things, both names are listed, because both get typed into a search box.
• Buildable today: a working implementation exists in a shipped framework, so you can use the pattern rather than admire it.
• Has a real failure mode: we can name what breaks first, which is a harder test of a pattern than naming what it is good at.
• Has a skip rule: there is a concrete case where a plain function, a queue or a cron job beats it, and we say so.
• Composable: it slots into the other six instead of replacing them.
• Cost visible: we can say in relative terms what the pattern does to your token bill.

Every pattern name, quoted framework behavior and cost multiplier here was read off the vendor source in August 2026. Framework APIs move fast and the argument names will drift. The pattern names have been stable since Anthropic published them, which is why they are the part worth memorizing.

The seven patterns at a glance

What are agentic workflows actually made of? Seven shapes: a chain, a switch, a fan-out, a manager with workers, a loop with a judge, a loop with tools, and a gate with a person behind it. If you have been hunting for an agentic AI workflow diagram, that list is what it would contain. Pick the one that matches the job you have, then read its skip rule before you write any code. Learning to recognize the shape first is most of what we teach in the automation and agentic systems course at Agentic School.

• Prompt chaining: a fixed sequence of model calls where each one works on the output of the last.
• Routing: one cheap classification step that sends each input to the specialized handler for its type.
• Parallelization: the same job fanned out across concurrent calls, either split into sections or voted on.
• Orchestrator-workers: a lead model invents subtasks at run time, delegates them, and merges the results.
• Evaluator-optimizer: one model drafts, another scores it against a rubric, and it revises until it passes or the budget runs out.
• The autonomous tool loop: the model picks its own tools in a loop and decides when it is finished.
• Human-in-the-loop checkpoint: the run pauses before a chosen action and waits for a person to approve, edit or reject it.

Prompt chaining

Prompt chaining splits a task into a fixed sequence of model calls, each taking the previous output as its input. Anthropic lists it first, LangGraph documents it under the same name, and the Google Agent Development Kit ships it as a Sequential Agent, which its docs call deterministic and predictable because it sets the execution order without consulting a model. It is also searched as a sequential workflow or an LLM pipeline. Reach for it first because the order lives in your code: you can drop an ordinary check between any two steps and abort before paying for the next call, which is the cheapest quality gate on this page. You pay in latency and compounding: three chained calls are three round trips, and step three inherits every mistake step one made.

• What it is: a fixed, code-defined sequence of model calls, each consuming the output of the one before it.
• Use it when: the task decomposes into steps you can name in advance, such as outline, then draft, then a tone rewrite.
• Skip it when: one well-written prompt already passes your evaluation. Splitting it then buys latency and nothing else.
• What breaks first: silent compounding. A bad step one yields a confident, well-formatted, wrong step three, so validate between links, not only at the end.

Routing

Routing puts one cheap classification call in front of several specialized handlers and sends each input to the right one. Anthropic and LangGraph both name it routing; the OpenAI Agents SDK implements a decentralized version through handoffs, which it describes as a mechanism for coordinating and delegating work across multiple agents. The economics are the whole appeal: a short classification prompt on a small model sends the easy majority of traffic down a cheap path and reserves the expensive model for the rest. The trade-off is that a misroute is silent. The specialized handler answers confidently in the wrong lane, and unless you log the chosen route beside the outcome you will never see it happen.

• What it is: a classification step that dispatches an input to one of several specialized downstream prompts, models or tools.
• Use it when: inputs fall into distinct categories that need different handling, and one prompt serving all of them keeps regressing.
• Skip it when: the category is decidable from structured data. A field check or a regular expression is free, instant and never hallucinates a category.
• What breaks first: silent misclassification. Log the route with the outcome, and always ship a default branch for inputs that match nothing.

Parallelization

Parallelization runs several model calls at once and combines the results. Anthropic splits it into two variants worth keeping separate: sectioning, where independent subtasks run concurrently, and voting, where the same task runs several times and you take the consensus. LangGraph documents both under parallelization and the Google Agent Development Kit ships the shape as a Parallel Agent. Sectioning buys wall-clock time. Voting buys confidence on judgment calls where a single sample is unreliable, such as flagging risky content. Neither is free: you pay full price for every branch, so a five-way vote costs about five calls and returns one answer.

• What it is: the same job fanned out across concurrent calls, either split into independent sections or repeated for a vote.
• Use it when: the subtasks genuinely do not depend on each other, or one sample of a judgment call is not reliable enough to act on.
• Skip it when: the steps depend on each other. Forcing a dependent chain into parallel branches produces contradictions you then reconcile by hand.
• What breaks first: the bill and the merge. Cost scales with the fan-out, and the step that combines disagreeing branches is where most real bugs live.

Orchestrator-workers

Orchestrator-workers has a lead model break a job into subtasks at run time, delegate them to workers, and synthesize the results. It is also called planner-executor, supervisor, or lead agent and subagents, and Andrew Ng's planning and multi-agent collaboration patterns both land here. The difference from parallelization is that nobody decides the subtasks in advance; the orchestrator invents them from the input. Anthropic used exactly this for its multi-agent research system, with a lead agent coordinating while specialized subagents worked in parallel. It is also the most expensive pattern here by a distance: Anthropic reports multi-agent systems use about 15x more tokens than chat interactions, and says plainly that they only make economic sense when the task is valuable enough to pay for it. Anthropic also names where it underperforms, and the answer is instructive: domains where every agent needs the same context or the subtasks have many dependencies, with coding cited as having fewer truly parallelizable subtasks than research.

• What it is: a lead model decomposes the task at run time, delegates the pieces to workers, and merges what comes back.
• Use it when: the subtasks are unpredictable, the work genuinely parallelizes, and the output is worth roughly an order of magnitude more tokens.
• Skip it when: every worker needs the same context, or the subtasks depend on each other. Anthropic names both as the conditions where multi-agent underperforms.
• What breaks first: cost and coordination. At about 15x the tokens of a chat turn, debugging a broken orchestrator is itself a line item worth budgeting for.

Evaluator-optimizer

Evaluator-optimizer puts a generator and a critic in a loop: one model drafts, a second scores it against a rubric, and the draft is revised until it passes or the budget runs out. Anthropic and LangGraph both use the evaluator-optimizer name; the single-model version is what Andrew Ng calls reflection, defined in his DeepLearning.AI letter as the LLM examining its own work to come up with ways to improve it. It is worth far more when the evaluator is not a model at all. A test suite, a type checker or a schema validator returns a hard pass or fail instead of a plausible opinion, which is why this pattern is the backbone of an agentic coding workflow. The failure is famous and avoidable: with no bound and a vague rubric, the pair will rewrite the same paragraph forty times, each version different and none better.

draft = generate(task)

for attempt in range(MAX_ROUNDS):  # bounded, never open ended
    verdict = evaluate(draft)      # a rubric, a test run, a type check
    if verdict.passes:
        break
    draft = generate(task, feedback=verdict.notes)

return draft, attempt  # log the round count: a rising trend is the early warning

• What it is: a generate, critique and revise loop that runs until an explicit quality bar is met or a round limit is hit.
• Use it when: quality is measurable and the first draft is reliably close but not right, especially when the evaluator can be a test rather than a model.
• Skip it when: you cannot write the rubric down. An evaluator with no clear criteria produces churn that looks like progress and costs like progress.
• What breaks first: the loop that never terminates. Bound the rounds, require the score to improve to earn another one, and log how many rounds each run took.

The autonomous tool loop

The autonomous tool loop is what most people mean when they say agent: the model gets tools and a goal, chooses which tool to call, reads the result, and decides for itself whether to call another or stop. It is also called ReAct, the agent loop, or simply tool use, the last being Andrew Ng's name for it. Anthropic defines agents as systems where the model dynamically directs its own processes and tool usage, which is exactly the line between this pattern and the six others. It is the only one where you do not know the path in advance, and that is both the point and the price: Anthropic reports agents use about 4x more tokens than chat interactions and warns that agentic systems trade latency and cost for task performance. Use it where you cannot predict the route but can still verify the result. Building this loop by hand is covered in our guide on building an AI agent from scratch, so this page stays on where it belongs.

• What it is: a model with tools running in a loop, choosing its own next action and its own stopping point.
• Use it when: the path cannot be hardcoded because it depends on what earlier steps discover, and the final result is still verifiable.
• Skip it when: the steps are known in advance. You are paying roughly 4x the tokens and adding non-determinism to reproduce what a scripted chain already does correctly.
• What breaks first: silent tool failure. A tool that returns a string on error lets the model read the failure as data and continue, so make failures typed and loud.

Human-in-the-loop checkpoint

The human-in-the-loop checkpoint pauses a run before a chosen action and waits for a person to approve, edit or reject it. It is a real pattern with real primitives, not a disclaimer: the OpenAI Agents SDK lists human in the loop among its built-in mechanisms for involving humans during agent runs, and LangGraph implements it as an interrupt whose documented use is pausing before critical actions such as API calls, database changes and financial transactions, with the option to edit the tool call arguments before they run. That edit capability is the underrated half. Approving a bad call is a coin flip; correcting the argument and continuing turns the checkpoint into a signal you can fold back into the prompt. The failure mode here is human: gate too many actions and the reviewer starts rubber-stamping, which is worse than no gate because it manufactures the appearance of oversight.

• What it is: an explicit pause before a selected action, where a person approves it, edits its arguments, or rejects it.
• Use it when: the action is irreversible, financial, customer-facing or hard to detect when wrong. Match the gate to the cost of a mistake.
• Skip it when: the action is cheap, reversible and high-volume. A gate there buys nothing and trains the reviewer to click approve without reading.
• What breaks first: rubber-stamping. Gate few genuinely dangerous actions, show the exact arguments, and let the reviewer fix the call rather than only accept or refuse it.

Agentic workflow vs plain automation

Here is the test, and it takes ten seconds: if the steps are known in advance and the inputs are structured, it is not an agentic workflow, and making it one costs money and adds failure modes. Anthropic draws the same line, defining workflows as systems where models and tools are orchestrated through predefined code paths and agents as systems where the model dynamically directs its own process. LangGraph phrases it almost identically. The Google Agent Development Kit calls its template workflow agents deterministic and predictable precisely because they set the execution sequence without consulting a model. So the real question is never whether agents are good. It is whether the decision you are handing to a model is a decision at all, or a branch you did not want to write. Agentic AI workflow automation earns its premium only when the next step depends on what an earlier step found.

• Steps known in advance, inputs structured: use a script, a queue or a workflow automation tool. No model needed anywhere in it.
• Steps known in advance, one step needs language or judgment: use a plain workflow with a single model call inside it. Still not an agentic workflow.
• Steps depend on what earlier steps discover, and the result is verifiable: this is where an agentic workflow earns its cost.
• Steps unpredictable and the result is not verifiable: do not automate it yet. An unverifiable autonomous loop only generates confident output nobody can check.
• Cost check first: Anthropic reports agents at about 4x the tokens of a chat interaction and multi-agent systems at about 15x. Multiply by your volume before you commit.

Failure modes and the guardrail for each

AI agentic workflows fail in five recognizable ways, and every one has a named guardrail that is cheap before launch and expensive to retrofit after an incident. Notice that none of them is a model quality problem. A better model makes each failure arrive later and cost more when it does, which is why teams that upgrade their way out of an incident tend to get a bigger version of it a quarter later. Guardrails are documented rather than improvised now: the OpenAI Agents SDK ships input and output guardrails whose tripwire raises immediately and halts the run, and input guardrails can run in blocking mode so a bad request is rejected before any tokens are spent. We treat this list as the minimum bar in the human-in-the-loop lesson at Agentic School.

• Loops that never terminate: bound every loop with a maximum round count and require measurable improvement to earn another round. An unbounded retry is the most common cause of a surprise bill.
• Silent tool failures: a tool returning an error string lets the model read the failure as data and carry on. Return typed failures and stop the run on the ones it cannot recover from.
• Cost blowups on retry: cap spend per run, not only per month, and fail closed at the cap. Retry logic times a 15x multi-agent token profile is how one test run outruns a monthly budget.
• No human checkpoint: interrupt before irreversible actions, which LangGraph documents specifically for API calls, database changes and financial transactions, and let the reviewer edit the arguments.
• No way to replay what happened: persist the run. LangGraph checkpointers save thread state for time travel and fault tolerance, and the OpenAI Agents SDK ships tracing for visualizing, debugging and monitoring workflows. Without one, every incident review is guesswork.

The seven agentic design patterns compared

These seven compose, and most agentic AI workflows in production are three of them wired together. Each line below carries the same four things in the same order: who controls the path, what it costs relative to a single call, what it is best at, and the thing to watch. Nothing here is new; every fact appears in the section above it.

• Prompt chaining: path controlled by your code, one call per step, best for tasks you can decompose in advance, watch for errors compounding down the chain.
• Routing: path controlled by one classification call, one cheap call plus one handler, best for mixed input types, watch for silent misclassification.
• Parallelization: path controlled by your code, cost multiplied by the fan-out, best for independent subtasks or consensus votes, watch the merge step and the bill.
• Orchestrator-workers: path controlled by a lead model at run time, about 15x a chat interaction per Anthropic, best for high-value work that parallelizes, watch shared-context tasks.
• Evaluator-optimizer: path controlled by a quality bar, one call per round, best when quality is measurable and ideally testable, watch for unbounded rewrite loops.
• The autonomous tool loop: path controlled by the model, about 4x a chat interaction per Anthropic, best when the route is unpredictable but the result is verifiable, watch for silent tool failures.
• Human-in-the-loop checkpoint: path controlled by a person at one point, near zero in tokens and real in wall-clock time, best before irreversible actions, watch for rubber-stamping.

Which agentic workflow pattern to pick

Three things decide it, and none of them is which pattern is most interesting. First, who has to control the path: if you can name the steps, your code should own them and the model should only fill in the parts that need language. Second, whether the output is verifiable, because a pattern you cannot check is a pattern you cannot safely automate. Third, what your volume does to the token multiplier, since a 4x or 15x premium that is trivial on ten runs a week is a budget line at ten thousand.

If you are one founder automating your own operations, start with prompt chaining plus a human checkpoint on anything touching money or a customer, and add routing only once you can point at the input types that keep breaking one prompt. If you are building an agentic coding workflow, use the autonomous tool loop with your test suite as the evaluator rather than a second model scoring prose, and bound the rounds. If orchestrator-workers is tempting, wait until the subtasks are genuinely unknown ahead of time, genuinely parallel and worth roughly fifteen times the tokens, because everything short of that runs better and cheaper as a chain.

The patterns above, the guardrails and the builds they came from are taught end to end in the free courses at Agentic School.

Frequently asked questions

Keep learning