1.2 The Three Architectural Patterns

Once you know the outcome and the constraints (Lesson 1.1), the next question is which SHAPE of system actually satisfies them. Anthropic frames every Claude-based system along a complexity gradient with three points on it: the augmented LLM, the workflow, and the agent. It's tempting to treat these as three unrelated options you pick from a menu — but the far more useful mental model is a gradient, because each point builds on the one before it, and moving up the gradient always costs something.

Think of it like modes of transport for getting across a city. Sometimes you walk — simple, predictable, no moving parts to break. Sometimes you follow a bus route — a fixed, predetermined path that gets you there reliably as long as the route actually goes where you need. And sometimes you need a taxi that improvises its own route around traffic you couldn't have predicted — more flexible, but you're now trusting the driver's real-time judgment instead of a timetable. Nobody takes a taxi to go two blocks, and nobody expects a fixed bus route to handle an emergency detour. Architecture selection is the same instinct: match the shape of the trip to the shape of the destination.

At the bottom of the gradient sits the augmented LLM — a single model call enhanced with retrieval, tools, and memory. This is the base building block of everything above it. When you strip away all the orchestration language, a "workflow" is just several augmented LLM calls wired together in a fixed order, and an "agent" is an augmented LLM given the freedom to decide its own order. Understanding the augmented LLM well is what makes the more complex patterns feel obvious rather than mysterious, because they're compositions of this one thing, not something categorically different.

"Augmented" means the call isn't relying on the model's training data alone — it can pull in retrieval (grounding context fetched from a knowledge base or document store), tools (real actions or lookups it can invoke), and memory (relevant state carried across turns or sessions). A single well-scoped step — classify this ticket, extract these fields from this document, answer this question against this retrieved context — is very often best served by exactly this: one augmented call, no orchestration layer at all.

The augmented LLM matters on the exam precisely because it's the pattern most often UNDER-selected. Architects reach for a workflow or an agent out of habit, when a single well-designed augmented call would have met every requirement at a fraction of the cost and latency. If a scenario describes one well-scoped step with no real branching or multi-stage need, the augmented LLM is very often the correct — if unglamorous — answer.

One step up the gradient is the workflow: LLM calls and tools orchestrated through predefined code paths that YOU write in advance. The defining property is that the control flow is fixed in your code, not decided by the model at runtime. This is what you reach for when a task decomposes into known, fixed steps, and predictability and testability matter more than adaptability — echoing the recipe-vs-exploration instinct from decomposition thinking, except here we're one level up, choosing the overall pattern rather than just the decomposition.

Workflows aren't a single technique — they're a family of five compositions, and knowing which fits which shape of task is squarely what the exam tests.

Look closely at orchestrator–workers: it's listed as a workflow composition, yet its defining feature is that the subtasks are decided AT RUNTIME by a central LLM, not fixed by you in advance. That's not a contradiction — it's the deliberate seam where the workflow pattern shades into the agentic pattern. We'll come back to that exact seam in the next section, because the exam builds a whole trap around it.

At the top of the gradient is the agentic pattern proper: a system where the LLM dynamically directs its own steps and tool use. Concretely, it runs an open-ended loop — plan, call a tool, observe real environment feedback, repeat — until it decides it's done or hits a stop condition. This should feel familiar if you've studied agentic loops before: the defining trait is that nobody wrote the sequence of steps in advance, because nobody COULD — the right next step depends on what the previous one revealed.

Agents fit open-ended tasks where the steps genuinely can't be enumerated ahead of time: exploring a codebase of unknown shape, investigating an incident where the cause is unknown, researching a broad question where what to look up next depends on what you just found. And agents pay for that flexibility in exactly the currencies you'd expect: latency (an unbounded number of steps takes an unbounded amount of time), cost (more model calls, more tokens), and predictability (you can't guarantee in advance what path it will take, which complicates testing and review).

Now the trap, and it's the single most important discriminator in this lesson: orchestrator–workers (a workflow composition) and the agentic pattern can look identical from a distance — both involve a central LLM handing off work dynamically. The dividing line is precise: WHO decides the subtasks, and WHEN. In orchestrator–workers, a central LLM decides the subtask breakdown at runtime and hands pieces to workers — but the overall shape (there IS a fixed manager/worker structure, a bounded task) is still a known, designed workflow. In a true agentic loop, there's no predetermined structure at all — the model decides its own next action, tool by tool, with no larger script constraining the shape of what happens next.

Let's put the whole gradient side by side with concrete tasks, because the exam rewards pattern-matching a scenario to its correct point on the gradient fast.

Notice the pattern in that table: every single row is decided by the SAME underlying question you learned in Lesson 1.1 — are the steps knowable in advance, and does predictability matter more than adaptability, or vice versa? The three-pattern gradient is really just that question, answered at increasing resolution.