What You Need to Know
Anthropic's Building Effective AI Agents names three tiers. An augmented LLM is a single model call with retrieval, tools and memory added. A workflow orchestrates LLMs and tools through predefined code paths. In an agent, the model dynamically directs its own processes and tool usage. Five workflow patterns and one decision rule complete the vocabulary.
A coach hire firm gets a high volume of requests: school trips, weddings and airport runs, each priced by its own rules. Replies must be fast, consistent and auditable.
The Three Tiers
The augmented LLM is the basic building block: for the firm, one call that retrieves prices and drafts a reply. For most business problems it is the whole answer. Production-grade does not mean multi-step.
In a workflow the developer decides the steps, such as classify then quote, and the model executes within them. Code fixes the path, so it is predictable, testable, consistent and auditable.
An agent loops on environment feedback until the goal is met. Its flexibility costs more tokens, higher latency, more ways to fail and a harder audit. Its paths are not predefined, so it needs guardrails, sandboxing and observability.
The Five Workflow Patterns
| Pattern | Selection cue | Shape |
|---|---|---|
| Prompt chaining | Task decomposes cleanly into fixed sequential subtasks | Step feeds step, optional programmatic gates between |
| Routing | Distinct input categories are better handled separately | Classifier dispatches to specialised handlers |
| Parallelisation | Subtasks are independent, or multiple perspectives help | Sectioning (split the work) or voting (repeat for confidence) |
| Orchestrator-workers | Subtasks cannot be predicted in advance | Central model decomposes dynamically, delegates to workers |
| Evaluator-optimizer | Clear evaluation criteria exist and iteration measurably helps | Generator loops against an evaluator until acceptable |
Each pattern has a precondition. Evaluator-optimizer without clear evaluation criteria is not a valid choice: with no written standard for a good quote, the firm's evaluator has nothing to check. Orchestrator-workers for steps known in advance is chaining with extra cost.
The Decision Rule
Anthropic's guidance is explicit: find the simplest solution that meets requirements, and add complexity only when it demonstrably improves outcomes.
- Escalate from augmented LLM to workflow to agent only when the simpler tier cannot meet a named requirement.
- Workflows beat agents when the steps are known. An agent given a fixed pipeline adds cost and unpredictability for nothing.
- Agents earn their cost when the path cannot be scripted: open-ended problem-solving, unknown step counts, decisions that depend on intermediate findings.
Worked Selection
For the firm:
- Distinct kinds of request, each quoted from the price list or passed to a booker by its own handler: routing is the cue-matched pattern.
- The steps are known: agent flexibility buys nothing, and its unpredictable paths hurt the audit requirement.
- Each request is one context window's worth of work: multi-agent overhead is unjustified.
The firm needs a routing workflow. The professional argument has four lines:
- Cue matched.
- Requirements met.
- Nothing simpler suffices.
- Nothing more complex earns its cost.
Practise it for any scenario.
In the exam
The exam expects the canonical vocabulary, used precisely. Most questions here are selection questions: a scenario with requirements, four architectures, one that fits. Preconditions are tested as preconditions.
The Exam Punishes Over-Engineering
The most reliable distractor is the impressive answer: deploy an autonomous agent, add a coordinator, go multi-agent. When the scenario names known steps, consistency, latency or auditability, the workflow answer wins. The exam punishes over-engineering as hard as under-engineering. Stems supply the requirements that make "simplest sufficient" decidable.
Exam Traps
Deploying an autonomous agent for a fixed, well-specified pipeline
The steps are known, so a workflow delivers the same result predictably and auditably at lower cost. The agent adds unpredictable paths for zero benefit — this is the exam's most common over-engineering distractor.
Confusing routing with prompt chaining
Distinct input categories want routing (classify, then dispatch to specialised handlers). Sequential dependent stages want chaining (step feeds step). The cue words in the stem — categories versus stages — tell you which.
Choosing evaluator-optimizer where no clear evaluation criteria exist
The pattern precondition is explicit criteria plus measurable value from iteration. Without criteria, the evaluator has nothing to evaluate against and the loop cannot terminate meaningfully.
One monolithic prompt for a task that needs staged quality gates
With no intermediate outputs to validate, errors surface only at the end. Chaining with programmatic gates between steps catches failures where they occur — under-engineering fails the same selection logic as over-engineering.
Practice Scenario
Support tickets must be classified into five categories, then either answered from a knowledge base or escalated to a human. Each category has its own answering rules, and a change to one category's rules must not alter answers in the others. Volume is high, latency matters, and behaviour must be consistent and auditable. Which architecture fits best?
Build Exercise
Pattern Selection Matrix
What you'll learn
- How to identify the selection cue for each of the five workflow patterns
- How to apply the simplest-solution decision rule to real tasks
- How to justify tier escalation with a named requirement the simpler tier fails
- How to argue a pattern choice the way the exam expects
- List five real tasks from your organisation that involve language processing — aim for variety, not similarity
Why: Pattern selection is a matching skill, and matching needs a spread of task structures to practise against.
You should see: Five one-line task descriptions, ideally spanning at least three different underlying structures.
- For each task, write the selection cues present: fixed subtasks, distinct categories, parallelisable parts, unpredictable subtasks, clear evaluation criteria
Why: The cues are the objective evidence a pattern choice rests on. Naming them first stops prestige-driven selection.
You should see: Each task annotated with one or two cues, or none — no cue at all points at a plain augmented LLM.
- Assign each task its tier (augmented LLM, workflow, agent) and its pattern where applicable, justifying each with the cue
Why: This is the exam skill itself: scenario in, cue-matched architecture out, argument attached.
You should see: Five assignments, each with a one-sentence justification naming the cue it rests on.
- For every task where you chose above augmented LLM, write one sentence on why the simpler tier fails
Why: The simplest-solution rule is only honest when the simpler tier gets an explicit rejection reason. This is also how to eliminate exam distractors quickly.
You should see: A rejection sentence per escalation naming the requirement the simpler tier cannot meet.
- Have a colleague challenge each choice with the question: what is the simplest design that still meets every stated requirement?
Why: The adversarial pass mirrors both design review and the exam format — every question is four defensible-sounding options with one that best fits the requirements.
You should see: At least one of your five choices downgraded or better justified after the challenge.
Sources
- Building Effective AI Agents — Anthropic
- Agent SDK overview — Anthropic