Workflow patterns cheat sheet.

A demo runs once, on a happy path, with you watching. Production runs a million times, on inputs you never imagined, while you sleep. Each failure mode has a defence, so name it before you ship.

One question separates them: are the steps fixed in code, or does the model choose them at run time?

flowchart LR
  subgraph WF["WORKFLOW · you drive"]
    direction LR
    A1["Step 1"] --> A2["Step 2"] --> A3["Output"]
  end
  subgraph AG["AGENT · the model drives"]
    direction LR
    M{"Model picks
next step + tool"}
    M --> T["Tool"] --> O["Observe"] --> M
    M -.-> DONE["Done"]
  end
  classDef wf fill:#D6F5E3,stroke:#1F2937,color:#0E1726;
  classDef ag fill:#EEE6FF,stroke:#1F2937,color:#0E1726;
  class A1,A2,A3 wf;
  class M,T,O,DONE ag;
    

Ordered simplest to most dynamic. Reach left first; every rung right is a cost you take only when forced. The line between workflow and agent is where the model, not you, starts picking the steps.

flowchart LR
  A["1 call"] --> B["Chain"] --> C["Router"] --> D["Parallelize"] --> E["Orchestrator"] --> F["Agent"]
  classDef s fill:#D6F5E3,stroke:#1F2937,color:#0E1726;
  classDef m fill:#DCEBFE,stroke:#1F2937,color:#0E1726;
  classDef a fill:#EEE6FF,stroke:#1F2937,color:#0E1726;
  class A,B s; class C,D,E m; class F a;
    

These cover most real work before you ever need an agent. Each is a handful of lines; the skill is knowing which one the task wants, and where it breaks.

# gate between steps: fail early and cheap
outline = llm("draft an outline", brief)
if not valid(outline):        # deterministic check
    return reject(outline)
draft = llm("write from outline", outline)
return llm("tighten and proof", draft)

# classify once, dispatch to the right-sized flow
kind = classify(request)      # small, fast model
match kind:
    case "faq":    return haiku(request)
    case "refund": return refund_flow(request)
    case _:        return opus(request)

# fan out independent work, then aggregate
parts = gather(
    llm("summarise", doc),
    llm("extract risks", doc),
    llm("list next actions", doc),
)
return merge(parts)   # or majority vote

# the planner decides the branches at run time
plan = orchestrator(task)   # -> list of subtasks
assert len(plan) <= MAX_SUBTASKS
results = gather(*[worker(s) for s in plan])
return synthesise(task, results)

# generate, critique, revise; ALWAYS cap
draft = generate(task)
for _ in range(MAX_ROUNDS):
    v = evaluate(draft, rubric)
    if v.passed: break
    draft = revise(draft, v.feedback)
return draft

A pattern is only as good as its gates. A gate is the check that decides whether output moves forward, gets revised, or gets rejected. Reach for the cheapest gate that actually catches the failure.

Real systems are not one pattern; they are trees of them. A router picks a branch, a branch is a chain, a chain fans out in parallel, the result passes an evaluator before it ships. Each node stays independently testable.

flowchart TB
  IN(["request"]) --> R{"Router"}
  R -- simple --> C1["1 call"]
  R -- structured --> CH["Chain w/ gates"]
  R -- research --> O["Orchestrator"]
  O --> P[["Parallel workers"]]
  C1 --> EV{"Evaluator"}
  CH --> EV
  P --> EV
  EV -- fail --> CH
  EV -- pass --> OUT(["response"])
  classDef s fill:#D6F5E3,stroke:#1F2937,color:#0E1726;
  classDef m fill:#DCEBFE,stroke:#1F2937,color:#0E1726;
  classDef a fill:#EEE6FF,stroke:#1F2937,color:#0E1726;
  class C1,CH s; class R,O,P m; class EV,OUT a; class IN s;
    

Three gates. An agent has to clear all three. Most features stop at the first, and that is a good thing.

flowchart TB
  START(["A task to build"]) --> Q1{"Steps known
in advance?"}
  Q1 -- yes --> WF["Use a WORKFLOW"]
  Q1 -- "no, open-ended" --> Q2{"Must it loop:
act, observe, decide?"}
  Q2 -- no --> WF
  Q2 -- yes --> Q3{"Worth the cost,
latency and risk?"}
  Q3 -- "not yet" --> WF
  Q3 -- yes --> AG["Use an AGENT
with guardrails + evals"]
  classDef wf fill:#D6F5E3,stroke:#1F2937,color:#0E1726;
  classDef ag fill:#EEE6FF,stroke:#1F2937,color:#0E1726;
  class WF wf; class AG ag;
    

An unguarded agent is the demo that dies in every one of the four ways at once. Before it touches production, put a ceiling on each axis it can run away on.

# the model drives; bound every axis
for step in range(MAX_STEPS):     # 1. iteration cap
    if spend > BUDGET: break       # 2. $ ceiling
    act = model(state, TOOLS)       # 3. allow-list
    if act.risky:
        require_human(act)          # 4. approval
    state = execute(act, timeout=30) # 5. sandbox+TO
    if act.done: break

Order-of-magnitude, not benchmarks. The point is the shape: an agent's worst case is "it never stops", which is why every rung right on the ladder is a bill you sign up for.

You can't debug what you can't replay, and you can't improve what you don't measure. Two flying-blind failure modes above have the same cure: traces and evals from day one.

• Reach left on the ladder; buy agency only when a gate forces it.
• Every loop gets a cap; every request gets a token budget.
• Price the worst case, not the happy path.
• Gate between steps with the cheapest check that catches the failure.
• Right-size the model per request; don't pay frontier prices for FAQs.
• Structured I/O everywhere; validate every model output before you trust it.
• If it's irreversible, a human approves.
• No traces, no evals, no ship.
• Patterns compose: real systems are trees of workflows, not one clever loop.