Agentic Workflows — the pattern library between one prompt and full autonomy

Before reaching for a full agent, reach for a workflow: control flow written in code, with the model doing the parts only a model can do. Five composable patterns cover almost everything you will build.

Walking the rows, each with its when and its connection to what you already know:

1 — Prompt chaining. Decompose sequentially: outline → draft → polish; extract → validate → format. The win is the compounding math inverted — three simple 99%-reliable steps beat one complex 90% mega-prompt — plus something subtler: checkable intermediate artifacts. Between steps, code can gate: does the outline have the required sections? Does the extraction parse? A failed gate retries one cheap step, not the whole task. Use whenever a task has a natural pipeline shape.

2 — Routing. Classify the input, dispatch to a specialized handler — different prompts, different models. This is Topic 38's router/cascade economics wearing its workflow clothes: support triage sending billing questions to a billing prompt, easy queries to the 8B, hard ones to the frontier model. The classifier itself is cheap (a small model or even embeddings). Use when inputs cluster into types that want genuinely different treatment — one prompt serving all types serves each badly.

3 — Parallelization. Two distinct flavors sharing one diagram. Sectioning: independent subtasks run concurrently (analyze five contracts, review each file) — a pure Topic 38 latency win. Voting: the same task run N times, then majority-vote or judge-pick — which you'll recognize as Topic 21's consistency checking, promoted from hallucination detector to reliability booster: scattered answers get outvoted, concentrated ones win. Use sectioning when subtasks are independent; voting when correctness matters more than cost.

4 — Orchestrator-workers. The bridge pattern — half workflow, half agent: a central LLM dynamically decides what subtasks are needed (unknowable in advance), spawns workers for each, synthesizes the results. Different from parallelization precisely in that the fan-out is model-decided: "research this company" might need three searches or eleven. This is the skeleton of every deep-research product, and it's one small step from the next topic — give each worker its own loop and you have multi-agent.

5 — Evaluator-optimizer. Generate, critique against explicit criteria, revise, loop until pass (with a max-rounds guard — always). This pattern works exactly when Topic 58's verification asymmetry holds: evaluating is easier than generating. Translation critique, code review against a spec, tone-checking a draft. When the evaluator is as unreliable as the generator, the loop just launders errors with extra steps — check the asymmetry before reaching for it.

The patterns compose freely — a router in front of chains, voting inside an orchestrator's workers, an evaluator gate at the end of everything — and composition is where real systems live.

---