What you will be able to do
- Select a workflow, autonomous agent, augmented LLM or Agent Skill for a use case from its stated reuse, governance and risk-profile constraints
- State the delegation boundary each pattern sets: what application code decides, what Claude decides at run time, and what a human or owning team keeps
- Explain why a more autonomous or more elaborate pattern loses to a simpler one when the constraints call for a fixed order, predictable latency or central ownership
- Recognise when shared guidance belongs in an Agent Skill rather than in an always-loaded file or in per-team copies
Key concept
Delegation boundary — The line an architecture draws between decisions fixed in your code and decisions Claude makes at run time. Picking a pattern means picking where that line sits: code owns the sequence in a workflow, Claude owns the path in an agent, and a Skill's owner controls what Claude can load.
1.Four patterns, one question: who decides the next step
Choosing a pattern for a Claude application is mostly a decision about who controls what. Some decisions sit in your application code and run the same way every time. Claude makes others while the task runs. Still others stay with a person or with the team that owns a piece of knowledge. The four patterns on the exam split these decisions differently, so the main thing to ask is who chooses the next step, not how capable the system is.
Anthropic groups every LLM-plus-tools system under the name agentic systems, then splits them into two kinds. In a workflow, LLMs and tools are orchestrated through predefined code paths. In an agent, the model directs its own process and its own tool use. Underneath both is the augmented LLM: a model call with retrieval, tools and memory attached. Agent Skills answer a different question. Each Skill packages instructions, metadata and optional scripts that Claude loads when a task calls for them, and any of the other patterns can use one.
Start with the simplest option. Agentic systems often trade latency and cost for better task performance, and many applications should not be agentic at all. Add complexity only when a stated constraint calls for it. When it does, use a workflow if predictability and consistency matter on a well-defined task. Use an agent when the task needs flexibility and the model has to make decisions at scale.
| Pattern | What code or an owner fixes | What Claude decides at run time | Fits when |
|---|---|---|---|
| Augmented LLM | Which tools and retrieval exist; how many turns a request gets | Its own search queries, which tool to call, what to retain | A single call with retrieval and in-context examples is enough |
| Workflow | The sequence of calls, the gates between them, how outputs are combined | The content of each step | The task decomposes into well-defined steps that must run predictably |
| Autonomous agent | The toolset, guardrails, stopping conditions and checkpoints | Its own process, tool usage and number of steps | The problem is open-ended and the step count cannot be predicted |
| Agent Skill | What the package contains, maintained by its owner | When to load it, by matching its description to the request | The same domain guidance is needed repeatedly across conversations |
Checkpoint 1 of 9· Match them up
Match each pattern to where it puts the delegation boundary: what is fixed in advance, and what Claude decides at run time.
Tap a term, then the definition that fits it.
The patterns differ in who decides the next step. In a workflow, predefined code paths fix the sequence. An agent directs its own process inside the limits code sets. The augmented LLM makes its choices within a bounded call. A Skill's owner controls the content, and Claude decides when to load it.
“Workflows are systems where LLMs and tools are orchestrated through predefined code paths.”Source: www.anthropic.com
2.The augmented LLM: retrieval and tools inside a bounded call
The augmented LLM is the starting point, and often all a use case needs. Current models use their augmentations themselves. They write their own search queries, choose which tool to call and decide what information to keep. So a system that uses tools is not automatically an agent. For many applications, optimising single LLM calls with retrieval and in-context examples is enough.
With an augmented LLM, the delegation boundary sits inside one request. Your code calls the API, provides the retrieval and the one lookup tool, and caps how many turns a request may take. Within that budget, Claude picks the search query and decides whether the plan lookup is needed. Three things follow. Claude answers directly, with no sequence of steps to plan. Response time and cost stay predictable because the turn count is bounded. And a wrong answer can be traced to one retrieval or one lookup, not to a long chain of the model's own decisions.
The tempting upgrades each break one of those constraints:
- A retrieval loop that runs until Claude judges coverage sufficient is agent behaviour. The model now sets the number of steps, so latency and cost vary from one question to the next.
- A fixed draft-check-polish chain is a workflow. Chaining trades latency for accuracy, which is the wrong trade when latency is the stated priority.
- A subagent for documentation search adds the multi-agent coordination overhead, typically 3–10x the tokens, to solve a context-pollution problem a single-turn question does not have. When isolation does pay off is covered in orchestrator and subagent decomposition.
How you build it also affects whether problems are easy to find. Frameworks simplify calling models and parsing tools, but they add layers of abstraction that can hide the actual prompts and responses. Calling the Claude API directly from your own code keeps both visible, and many patterns take only a few lines.
Checkpoint 2 of 9· Check yourself
An internal HR assistant answers one-off policy questions from a document index. It can also call one read-only API to fetch an employee's leave balance. The team's priorities are predictable response time and being able to trace a wrong answer to its cause. Which design fits these constraints?
Choosing queries and tools does not make the system an agent. The augmented LLM already does that within a single call. Capping turns keeps latency and cost predictable, and a wrong answer traces back to one retrieval or one lookup. The agent loop lets the model set the step count. The chain trades latency for accuracy. The subagent adds coordination overhead to fix a context problem that single-turn questions don't have.
“Our current models can actively use these capabilities—generating their own search queries, selecting appropriate tools, and determining what information to retain.”Source: www.anthropic.com
Checkpoint 3 of 9· Exam question
A SaaS company wants a help-center assistant that answers single-turn product questions from its documentation and, when asked, looks up the customer's plan tier through one read-only API. Latency matters and the support team wants bad answers to be easy to diagnose. Choose two reasons that justify an augmented LLM over a full agent loop.(Select 2)
Correct answers: B, E — Handling a question as one retrieval plus at most one plan lookup lets Claude answer directly and skip planning its own sequence of steps.; Limiting a request to a few model turns keeps response time and cost predictable and lets a bad answer be traced to one retrieval or one lookup.
- A. Subagents with separate context windows help long, multi-part investigations where context fills up. A single-turn question with one retrieval has no context to protect, and spawning a subagent only adds a call and delays the reply.
- B. Correct: each question needs one documentation retrieval and at most one read-only plan lookup. That fixed shape is what an augmented LLM handles directly, with no planning loop to pay for.
- C. A fixed chain of prompts is a separate workflow pattern. It adds sequential model calls, which works against the latency need, and nothing in the scenario calls for staged review. It would not justify an augmented LLM.
- D. Repeating retrieval until the model is satisfied is the defining behaviour of a full agent loop. It makes turn count and latency unpredictable and traces harder to read, while the scenario is single-turn with one lookup.
- E. Correct: with few model turns per request, response time and cost stay predictable. A bad answer then traces back to one retrieval or one lookup result, whereas agent loops multiply turns and blur where a failure started.
3.Workflows: when code must own the sequence
A workflow puts control flow in your code. Claude does the work of each step, and the program decides which call comes next, what gets checked between calls and how outputs are combined. That split makes a workflow the right choice when an auditor, a regulator or a cost ceiling needs every run to behave the same way. The five common workflow shapes differ in how the program arranges the calls.
| Workflow | How the calls are arranged | Choose it when |
|---|---|---|
| Prompt chaining | Each call processes the previous output; programmatic gates can check intermediate steps | The task decomposes cleanly into fixed subtasks; you trade latency for accuracy |
| Routing | An input is classified and sent to a specialised follow-up prompt, process or tool | Distinct categories are better handled separately and can be classified accurately |
| Parallelization | Independent subtasks run at once (sectioning), or the same task runs several times (voting) | Subtasks are independent, or multiple attempts give higher confidence |
| Orchestrator-workers | A central LLM breaks the task down, delegates to workers and synthesises results | You cannot predict the subtasks in advance, e.g. how many files a change touches |
| Evaluator-optimizer | One call generates while another evaluates and gives feedback in a loop | Evaluation criteria are clear and iterative refinement adds measurable value |
For a fixed, audited pipeline, prompt chaining wins. Application code uses the Client SDK, which gives direct access to the Claude API, and makes one call per step. A gate after each call can stop the run when an extracted field is missing, before the next step drafts anything. Each call gets a smaller, easier task, and the code alone fixes the order. The higher latency of several sequential calls is the accepted cost.
The other options each fail on one specific point. An agent given extract, validate, draft and log tools, with the order written in its system prompt, still decides its own process: the prompt describes the sequence, but nothing enforces it, and the agent loop adds cost on high-volume work. Parallelization does not fit dependent steps, because validation needs the fields that extraction produces, and sectioning only applies to independent subtasks. Orchestrator-workers exists for work whose subtasks change with each input, which is the opposite of an order that must never change.
Routing belongs in this family for a separate reason: specialised prompts. When one prompt serves very different inputs, tuning it for one kind of input can make it worse on another. Classifying first and sending each class to its own prompt keeps those concerns apart, as long as the classification is accurate.
Checkpoint 4 of 9· Check yourself
A claims team runs a gated prompt chain: extract fields from a claim, validate those fields against policy, then draft a decision. To cut latency, an engineer proposes running the extraction and validation calls concurrently. What should the architect decide?
Sectioning runs independent subtasks in parallel. Validation depends on the output of extraction, so the two steps must run in order. Voting repeats the same task and does not remove that dependency. Orchestrator-workers hands control of the steps to a model, which gives up the fixed order the chain guarantees.
“Sectioning: Breaking a task into independent subtasks run in parallel.”Source: www.anthropic.com
Checkpoint 5 of 9· Exam question
An insurer's claims team must push every submission through the same four steps: extract fields, validate them against policy data, draft a determination letter, and log the result for audit. Auditors require the step order to be identical on every run, and volume is high with tight cost limits. As the solution architect, which pattern should you select?
Correct answer: A — Prompt chaining: application code calls Claude once per step in a defined sequence, checking each output before passing it to the next call.
- A. Correct: the steps are known and dependent, and auditors need the same order on every run. Code that sequences one bounded Claude call per step enforces that order, lets each output be checked and logged, and keeps the number of calls, and so the cost, predictable at high volume.
- B. A sequence described in a system prompt is only an instruction. The model still decides at run time which tool to call next, so the identical-order audit requirement can be broken on a given claim. The open-ended loop also adds extra turns and cost for steps that are already known.
- C. Parallelization suits independent subtasks. Here validation needs the extracted fields and the letter needs the validation result, so the steps depend on each other and cannot run side by side. Concurrent calls also give no fixed step order for auditors.
- D. Orchestrator-workers is built for tasks whose subtasks cannot be predicted in advance. A lead model that plans the subtasks per claim can produce a different order on different runs, which fails the audit requirement. The extra planning calls also raise cost for a process whose steps are already known.
4.Autonomous agents: delegating the path, keeping the guardrails
An agent is the right pattern when no one can write the path down in advance. Typical cases are open-ended problems where the number of steps cannot be predicted and a fixed path cannot be hardcoded: a coding agent editing many files to resolve an issue, or Claude operating a computer to finish a task. The model may run for many turns, so you need some level of trust in its decisions. That is why agents suit scaling tasks in trusted environments.
The implementation is usually simple: an LLM using tools in a loop and reacting to what the environment returns. The risk lies in the boundary. Autonomy means higher costs and the possibility that errors compound across steps. Each step should therefore get ground truth from the environment, such as a tool result or code execution output, to check progress. Agents should also be tested extensively in sandboxed environments, with guardrails in place, before they run anywhere that matters.
Delegating the path still leaves several decisions with humans:
- The agent starts from a human command or discussion, and can pause for human feedback at checkpoints or when it hits a blocker.
- Stopping conditions, such as a maximum number of iterations, keep the loop under control even when the task never clearly finishes.
- Runtime permissions control which tools run automatically and which need approval, so higher-risk actions wait for a person while routine reads go ahead.
The human-versus-Claude task split covers how to decide which actions need that sign-off.
Because the loop is simple, the toolset is where most of the design effort goes. Clear tools with good documentation do more for an agent's reliability than extra layers of orchestration. A well-designed single agent with appropriate tools often does more than developers expect, and splitting it into several agents typically multiplies token use for the same task.
Checkpoint 6 of 9· Check yourself
Your platform team wants Claude to fix failing builds after a library upgrade. One failure may need an edit to a single file, while another needs edits to forty, and no one can say in advance which edits are needed. The work runs in a sandbox where the test suite is available. Which design fits?
No one can predict the number of steps or hardcode a path, so this is agent territory. The boundary stays in place through test results as ground truth at each step and an iteration cap as a stopping condition. A chain needs fixed subtasks. Splitting the work by role multiplies token use. A file list in the prompt only guides the agent and bounds nothing.
“open-ended problems where it’s difficult or impossible to predict the required number of steps, and where you can’t hardcode a fixed path.”Source: www.anthropic.com
5.Agent Skills: one owned package of expertise, reused everywhere
Skills address a reuse and governance problem, not a control-flow one. A Skill is a directory with a SKILL.md file, plus optional reference files and scripts, that gives Claude domain-specific expertise. Prompts are conversation-level instructions for one-off tasks. A Skill loads on demand, so the same guidance does not have to be repeated in every conversation or copied into every team's configuration.
Within a Skill, Claude decides when and the owner decides what. Claude's system prompt always contains each Skill's name and description, and the description is what Claude matches a request against when deciding whether to trigger the Skill. Only then does the body enter context; the mechanics of that staged loading are covered in progressive disclosure. The owning team writes the instructions and bundled scripts. Scripts run through bash and only their output enters context, so their operations are deterministic, which suits steps that must not vary.
---
name: pdf-processing
description: Extract text and tables from PDF files, fill forms, merge documents. Use when working with PDF files or when the user mentions PDFs, forms, or document extraction.
---For reuse, the API is where the scope comes from. Custom Skills uploaded through the Skills API are shared workspace-wide, so every team's agents use the one version a central group maintains. In Claude Code, Skills live in ~/.claude/skills/ for personal use or .claude/skills/ for a project. Compare five teams each keeping their own copy of a house style: every copy drifts separately, and a monthly change means five edits. Copying the guidance into each team's subagent definition, or pasting an emailed update into system prompts, has the same problem. One Skill with one owner removes it.
| Aspect | CLAUDE.md | Skill |
|---|---|---|
| Loads | Every session, automatically | On demand |
| Best for | 'Always do X' rules | Reference material, invocable workflows |
That load timing settles the choice between a shared CLAUDE.md and a Skill. Guidance needed only for report-writing sessions does not belong in a file every session loads. It costs context in every unrelated session and applies rules where they do not fit. A Skill stays out of the way, apart from its name and description, until a matching task appears.
Central ownership needs governance, because a Skill can carry scripts and instructions that change what Claude does. Anthropic's enterprise guidance has admins vet every Skill before deployment, using a risk assessment and a review checklist. The risk assessment rates each Skill against seven indicators. Five carry a High concern level: code execution (scripts in the Skill directory run with full environment access), instruction manipulation, MCP server references, network access patterns and hardcoded credentials. Filesystem access scope and tool calls are rated Medium.
The review checklist is the hands-on part of that vetting. A reviewer reads all of the Skill's directory content, runs its scripts in a sandbox to confirm they match the stated purpose, and looks for adversarial instructions, external URL fetches or network calls, and hardcoded credentials. The reviewer also lists every tool and command the Skill tells Claude to run, and looks for patterns that read sensitive data and send it elsewhere. The checklist matters most on the API: Skills uploaded through the Skills API are not scanned, so for API deployments the checklist and version pinning are the controls. Pinning ties a deployment to one specific, reviewed version of the Skill, which is why the registry records each version and a new one is promoted only after evaluation passes.
Ownership runs through the enterprise lifecycle, which moves each Skill through planning, create and review, test, deploy, monitor, and iterate or deprecate. Three controls in that lifecycle keep the owner accountable:
- Separation of duties: Skill authors do not review their own Skills.
- An evaluation suite of 3–5 representative queries per Skill, covering should-trigger, should-not-trigger and ambiguous cases, run alone and alongside existing Skills. Without the coexistence run, an overly broad description can steal triggers from other Skills.
- An internal registry entry recording each Skill's purpose, owner and version, with the full suite required to pass before a new version is promoted.
Checkpoint 7 of 9· Fill the gap
Claude matches each incoming request against one frontmatter field to decide whether to trigger this Skill. Which key belongs in the blank?
---
name: pdf-processing
? : Extract text and tables from PDF files, fill forms, merge documents. Use when working with PDF files or when the user mentions PDFs, forms, or document extraction.
---Claude matches requests against the description field. That is why the description has to say both what the Skill does and when to use it. There is no separate triggers or when_to_use key, so the 'Use when…' sentence goes inside the description.
Source: platform.claude.comCheckpoint 8 of 9· Check yourself
A central compliance group maintains report-writing guidance that five product teams' Claude agents need, but only when they draft regulatory reports. The guidance changes monthly. Where should it live?
Only a Skill uploaded through the Skills API gives one centrally owned version that every team uses, and it costs only its name and description until a report task triggers it. A shared CLAUDE.md loads in every session, including unrelated ones. Copies in each team's configuration drift apart, and every monthly change means several edits.
“This lightweight approach means you can install many Skills without context penalty: until a Skill is triggered, only its name and description occupy context.”Source: platform.claude.com
Checkpoint 9 of 9· Exam question
Five product teams each run Claude-based agents that produce quarterly customer reports, and each team maintains its own copy of the house format, terminology and checklist. Reports drift between teams. The guidance changes monthly, a central documentation group should own it, and only report-writing sessions need it. Which pattern best fits these reuse and governance constraints?
Correct answer: C — Package the guidance as an Agent Skill maintained by the documentation group, which each team's agents pull in when a report task comes up.
- A. A shared CLAUDE.md gives the documentation group one place to maintain the guidance, but its contents are loaded at the start of each session. Sessions that never write a report would carry the format, terminology and checklist in context too, and only report-writing sessions need them.
- B. A template gives the subagents a common starting point, but the guidance is copied into each team's definition file. Because the guidance changes monthly, the copies would have to be edited by hand in five places and would drift, and the documentation group would not control the live text.
- C. Correct: an Agent Skill packages instructions and reference material as a single artifact the documentation group can update. Agents load it only when a task matches its description, so only report-writing sessions pay the context cost, and all five teams use the same current version.
- D. Emailing monthly updates and pasting them leaves five separate copies, each depending on a team applying the change on time, so reports keep drifting. Text in a system prompt is also present in every session of those agents, including sessions that never involve reports.
Sources
(6)
Every claim above is drawn from one of these pages, quoted as it was written on the date shown.
- 1.https://www.anthropic.com/engineering/building-effective-agentsSecondary source
“Workflows are systems where LLMs and tools are orchestrated through predefined code paths.”
↩︎ Four patterns, one question: who decides the next step“Agentic systems often trade latency and cost for better task performance, and you should consider when this tradeoff makes sense.”
↩︎ Four patterns, one question: who decides the next step“workflows offer predictability and consistency for well-defined tasks”
↩︎ Four patterns, one question: who decides the next step“The basic building block of agentic systems is an LLM enhanced with augmentations such as retrieval, tools, and memory.”
↩︎ The augmented LLM: retrieval and tools inside a bounded call“they often create extra layers of abstraction that can obscure the underlying prompts and responses, making them harder to debug.”
↩︎ The augmented LLM: retrieval and tools inside a bounded call“This workflow is ideal for situations where the task can be easily and cleanly decomposed into fixed subtasks.”
↩︎ Workflows: when code must own the sequence“The main goal is to trade off latency for higher accuracy, by making each LLM call an easier task.”
↩︎ Workflows: when code must own the sequence“Without this workflow, optimizing for one kind of input can hurt performance on other inputs.”
↩︎ Workflows: when code must own the sequence“The autonomous nature of agents means higher costs, and the potential for compounding errors.”
↩︎ Autonomous agents: delegating the path, keeping the guardrails“you must have some level of trust in its decision-making”
↩︎ Autonomous agents: delegating the path, keeping the guardrails“stopping conditions (such as a maximum number of iterations) to maintain control”
↩︎ Autonomous agents: delegating the path, keeping the guardrails“Agents, on the other hand, are systems where LLMs dynamically direct their own processes and tool usage, maintaining control over how they accomplish tasks.”
↩︎ Key concept“Workflows are systems where LLMs and tools are orchestrated through predefined code paths.”
↩︎ Exam trap 1“Sectioning: Breaking a task into independent subtasks run in parallel.”
↩︎ Exam trap 2“For many applications, however, optimizing single LLM calls with retrieval and in-context examples is usually enough.”
↩︎ Exam trap 3“Our current models can actively use these capabilities—generating their own search queries, selecting appropriate tools, and determining what information to retain.”
↩︎ Checkpoint“Workflows are systems where LLMs and tools are orchestrated through predefined code paths.”
↩︎ Prediction“Sectioning: Breaking a task into independent subtasks run in parallel.”
↩︎ Checkpoint“open-ended problems where it’s difficult or impossible to predict the required number of steps, and where you can’t hardcode a fixed path.”
↩︎ Checkpoint - 2.
“Each Skill packages instructions, metadata, and optional resources (scripts, templates) that Claude uses automatically when relevant.”
↩︎ Four patterns, one question: who decides the next step“Skills are reusable, filesystem-based resources that give Claude domain-specific expertise”
↩︎ Agent Skills: one owned package of expertise, reused everywhere“The description is what Claude matches your request against when determining whether to trigger the Skill”
↩︎ Agent Skills: one owned package of expertise, reused everywhere“Custom Skills are shared workspace-wide: all workspace members can access them.”
↩︎ Agent Skills: one owned package of expertise, reused everywhere“until a Skill is triggered, only its name and description occupy context.”
↩︎ Exam trap 4“This lightweight approach means you can install many Skills without context penalty: until a Skill is triggered, only its name and description occupy context.”
↩︎ Checkpoint - 3.
“multi-agent implementations typically use 3-10x more tokens than single-agent approaches for equivalent tasks.”
↩︎ The augmented LLM: retrieval and tools inside a bounded call“A well-designed single agent with appropriate tools can accomplish far more than many developers expect.”
↩︎ Autonomous agents: delegating the path, keeping the guardrails - 4.https://code.claude.com/docs/en/agent-sdk/overviewOfficial docs
“Call the Claude API directly from your own code”
↩︎ The augmented LLM: retrieval and tools inside a bounded call“Direct access to the Claude API from any of the client SDK languages.”
↩︎ Workflows: when code must own the sequence“Control which tools run automatically, which need approval”
↩︎ Autonomous agents: delegating the path, keeping the guardrails - 5.https://code.claude.com/docs/en/features-overviewOfficial docs
“Every session, automatically”
↩︎ Agent Skills: one owned package of expertise, reused everywhere - 6.
“Evaluate each Skill against these risk indicators before approving deployment:”
↩︎ Agent Skills: one owned package of expertise, reused everywhere“High: scripts run with full environment access”
↩︎ Agent Skills: one owned package of expertise, reused everywhere“Read all Skill directory content.”
↩︎ Agent Skills: one owned package of expertise, reused everywhere“Establish separation of duties: Skill authors should not be their own reviewers.”
↩︎ Agent Skills: one owned package of expertise, reused everywhere“Document the Skill in your internal registry with purpose, owner, and version.”
↩︎ Agent Skills: one owned package of expertise, reused everywhere“so for API deployments, rely on the review checklist and version pinning”
↩︎ Agent Skills: one owned package of expertise, reused everywhere