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.
This lesson uses one made-up example throughout: a university student services office that gets a high volume of requests about fees, course changes and exam dates. Each kind of request has its own rules. Replies must be fast, consistent and auditable, because a student can appeal a decision.
The Three Tiers
The augmented LLM is the basic building block. For the university, it is one call that retrieves the rules and drafts a reply. For most business problems it is enough on its own. A system that is ready for production does not have to have many steps.
In a workflow the developer decides the steps, such as classify then answer, and the model executes within them. Code sets the path, so the workflow is predictable, testable, consistent and auditable.
An agent works in a loop and uses feedback from its environment until it meets the goal. Its flexibility has 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. Sandboxing runs the agent in an isolated environment that limits what it can change. Observability is the logs and traces that show what the agent did.
The Five Workflow Patterns
| Pattern | Selection cue | Shape |
|---|---|---|
| Prompt chaining | Task decomposes cleanly into fixed sequential subtasks | Step feeds step, optional programmatic gates (checks in code) 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 reply, the university's evaluator has nothing to check. When the steps are known in advance, orchestrator-workers does the same work as prompt chaining at 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 are better than agents when the steps are known. An agent given a fixed pipeline adds cost and unpredictability with no benefit.
- Agents are worth their cost when the path cannot be scripted. This includes open-ended problem-solving, unknown step counts, and decisions that depend on intermediate findings.
Worked Selection
For the university:
- The university has distinct kinds of request. Each kind has its own handler, which answers the request from the rules or passes it to a member of staff. Routing is the pattern whose selection cue matches this.
- The steps are known. So agent flexibility adds nothing, and the unpredictable paths of an agent conflict with the audit requirement.
- Each request is work for one context window, so multi-agent overhead is unjustified.
The university needs a routing workflow. The argument for this choice has four parts:
- The pattern matches the cue.
- The pattern meets the requirements.
- Nothing simpler suffices.
- Nothing more complex is worth its cost.
Practise it for any scenario.
In the exam
The exam expects the canonical vocabulary, used precisely. Most questions here are selection questions with a scenario, its requirements and four architectures. One architecture fits. The exam treats each pattern's precondition as a requirement: without it, the pattern is the wrong choice.
The Exam Punishes Over-Engineering
The most common wrong option is the impressive answer: deploy an autonomous agent, add a coordinator, move to multiple agents. When the scenario names known steps, consistency, latency or auditability, the workflow answer is correct. The exam penalises over-engineering as much as under-engineering. The questions supply the requirements that you need to decide what is "simplest sufficient".
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 no benefit, and the exam often offers it as the over-engineered option.
Choosing prompt chaining when the scenario describes distinct input categories
Distinct input categories need routing (classify, then dispatch to specialised handlers). Sequential dependent stages need chaining (step feeds step). The scenario wording, categories versus stages, tells you which.
Choosing evaluator-optimizer where no clear evaluation criteria exist
The pattern needs explicit criteria plus measurable value from iteration. Without criteria, the evaluator has nothing to evaluate against and the loop cannot terminate meaningfully. Write the criteria down first, then decide whether a loop is worth its cost.
One monolithic prompt for a task that needs staged quality gates
With no intermediate outputs to validate, errors appear only at the end. Chaining with programmatic gates between steps catches failures where they occur.
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 range 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 you from choosing a pattern because it sounds impressive.
You should see: Each task annotated with one or two cues, or none — no cue at all indicates 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: read the scenario, choose the architecture whose cue matches it, and give the argument.
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 applied correctly when you give an explicit reason to reject the simpler tier. This is also how to eliminate wrong exam options 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: This challenge is similar to 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