Lesson 0004 · Domain 1 (27%) · Claude Certified Architect — Foundations

Orchestration patterns: workflows vs agents

The 5 patterns, when each fits, and the two distinctions the exam loves. ~10 minutes. Diagrams: Anthropic.
Why you're here. Domain 1 is the heaviest slice (27%), and its questions hinge on picking the right pattern for a scenario — plus spotting over-engineering in the distractors. This lesson is the pattern menu from Anthropic's Building effective agents.

0 · The meta-rule (often the correct answer)

Start with the simplest thing; add complexity only when it demonstrably improves outcomes — weighed against cost and latency.

Exam tell: distractors that bolt on a routing layer, a separate ML classifier, or more tools when a simpler fix (better prompt, better tool description) would do are usually wrong. When unsure between a simple and a complex option, prefer simple.

1 · The building block: the augmented LLM

Every pattern is built from one block: an LLM augmented with retrieval + tools + memory, behind a well-documented interface (MCP is one standard way to wire tools in).

The augmented LLM: a model with retrieval, tools, and memory.
The augmented LLM — model + retrieval + tools + memory.

2 · Workflow vs Agent (≈ Domain 1.6)

WorkflowAgent
Controlpredetermined code pathsLLM decides next steps in a loop, from environment feedback
Use whentask well-defined, predictable sequence, latency-sensitiveopen-ended, step count unpredictable, needs autonomy
Cost / riskpredictable, consistenthigher cost + error compounding → needs guardrails / sandbox
Autonomous agent loop: plan, act with tools, observe environment feedback, repeat, pause at checkpoints.
Autonomous agent — acts in a loop on environment feedback, pausing at checkpoints.

3 · The five patterns

Prompt chaining

Sequential steps; each call uses the previous output, with programmatic gates checking intermediate results.

Prompt chaining: LLM call 1 → gate → LLM call 2 → ... in a fixed sequence.
Prompt chaining — fixed sequence with validation gates.

Use when: subtasks are fixed and decomposing simplifies each call (outline → draft; draft → translate).

Routing

Classify the input, then send it to a specialized prompt/model.

Routing: a classifier directs each input to one of several specialized downstream handlers.
Routing — classify, then dispatch to a specialized handler.

Use when: distinct categories need different handling; or route easy→small model, hard→big model.

Parallelization — sectioning vs voting

Run calls at once and aggregate. Sectioning = split into independent subtasks. Voting = run the same task several times for confidence.

Parallelization: multiple LLM calls run simultaneously and their outputs are aggregated.
Parallelization — concurrent calls, aggregated. Sectioning (independent parts) vs voting (same task ×N).

Use when: speed (sectioning) or higher confidence via multiple looks (voting — e.g., several independent code reviews).

Orchestrator–workers

A central LLM dynamically decomposes the task, delegates to workers, and synthesizes.

Orchestrator-workers: a central orchestrator LLM spawns worker LLMs for dynamically-determined subtasks and synthesizes their results.
Orchestrator–workers — subtasks decided at runtime, then synthesized.

Use when: subtasks can't be predetermined — they depend on the specific input (multi-file code changes, research).

Evaluator–optimizer

One LLM generates; another critiques in a loop until criteria are met.

Evaluator-optimizer: a generator LLM and an evaluator LLM loop, refining the output each round.
Evaluator–optimizer — generate → critique → refine, in a loop.

Use when: clear eval criteria exist and iteration measurably helps (literary translation, multi-round search).

The distinction the exam tests most: parallelization vs orchestrator–workers

Both fan out to multiple calls. The split is when the subtasks are decided:

Echo of Lesson 0003: emitting several Task calls in one turn for known independent work = sectioning; a coordinator that figures out the split per query = orchestrator–workers. Either way, subagents share no memory.

Practice — pick the pattern, dodge the over-build

Primary source

📖 Read once: Anthropic's Building effective agents — the source of these patterns and diagrams. Pair with the multi-agent research system for orchestrator–workers in production.