Domain 1 at a glance
- Weight
- 27%
- Questions
- ~16 of 60
- Pass line
- 720/1000
- Study time
- ~45 min
Agentic Architecture & Orchestration is the largest domain on the exam. Scenario questions that reward the simplest design that works and rules enforced in code, not in the prompt.
- The agentic loop (gather context, take action, verify work)
- Workflows vs agents and the start-simple principle
- Prompt chaining, routing, parallelization, orchestrator-workers, evaluator-optimizer
- Multi-agent coordination and subagent spawning
- Session and state management, checkpointing, resumability
- Single-agent vs multi-agent trade-offs for production
- Agent guardrails: permissions, sandboxing, stopping conditions
Domain 1 task statements
Domain 1 is the largest slice of the exam. Each row below is a skill the blueprint tests, what it means in practice, and the trap that the distractors are built around.
| Task | What it means | The trap |
|---|---|---|
| The agentic loop | Call the model, act on stop_reason, run tools, feed results back, repeat | Ending the loop by parsing prose instead of stop_reason |
| Workflow vs agent | Fixed code paths when the steps are known, an agent only when they are not | Reaching for an autonomous agent because the task feels complex |
| Decomposition | Split work into subtasks with clear owners and no overlap | Over-decomposing until coordination costs more than the work |
| Sequential vs parallel | Chain dependent steps, fan out independent ones | Spawning subagents one per turn when they could run together |
| Hub-and-spoke orchestration | One coordinator delegates to specialists and synthesizes | Letting specialists talk to each other directly |
| Handoff schemas | Delegation carries goal, context, quality bar and return format | Vague one-line delegation that leaves subagents guessing |
| Session state | Resume, fork or start fresh with a summary and durable files | Assuming a subagent or new session remembers anything |
| Guardrails and escalation | Hooks and permissions enforce rules, humans get a structured brief | Adding MUST to the prompt and calling it enforcement |
The agentic loop, explained
Anthropic describes every agent as the same loop: gather context, take action, verify the work, repeat. In API terms your harness sends the conversation and the tool definitions, then reads stop_reason on the response. If it is tool_use, the assistant message contains one or more tool_use blocks. You run each tool and send back ONE user message that contains a tool_result block for every tool_use_id, then call the model again.
The loop ends when stop_reason is end_turn (or another terminal reason you handle on purpose). An iteration cap is a safety net, not the exit condition. If your harness only stops when the cap fires, the agent is failing silently and you are paying for it.
Two details carry a lot of exam weight. Parallel tool calls come back as several tool_use blocks in a single assistant turn, and all of their results belong in a single user message; splitting them across messages, or leaving one out, returns a 400. And tool_result blocks must come first in that user message, before any text.
messages = [{"role": "user", "content": task}]
for _ in range(MAX_TURNS): # safety net, not the exit
resp = client.messages.create(model=MODEL, max_tokens=4096,
tools=TOOLS, messages=messages)
messages.append({"role": "assistant", "content": resp.content})
if resp.stop_reason != "tool_use":
break # end_turn, max_tokens, refusal... handled below
results = [
{"type": "tool_result", "tool_use_id": b.id,
"content": run_tool(b.name, b.input)}
for b in resp.content if b.type == "tool_use"
]
messages.append({"role": "user", "content": results}) # ONE messageOn the exam, watch for a harness that appends one user message per tool result, or that ends the loop when the text says "done".
stop_reason: what your harness does next
| Value | Meaning | Correct harness action | Exam trap |
|---|---|---|---|
end_turn | The model finished its turn | Exit the loop, return the answer | Checking the text for "done" instead |
tool_use | The model wants one or more tools run | Run every tool, return all results in one user message | One message per result |
max_tokens | Output hit your max_tokens cap | Raise the cap or continue; never parse the partial output as complete | Parsing truncated JSON as if it were valid |
stop_sequence | A custom stop string was produced | Handle per your format; stop_sequence says which one | Expecting the stop string in the returned text |
pause_turn | A long server tool turn was paused | Send the response back as-is so the model resumes | Restarting the request from scratch |
refusal | The model declined for safety reasons | Surface it or route to a human; do not blindly retry | Retrying the same request in a loop |
model_context_window_exceeded | The context window filled during generation | Compact or trim, then continue | Treating it like a 400 and dropping the turn |
Workflow vs agent vs multi-agent
"Building effective agents" separates workflows (LLM calls on predefined code paths) from agents (the model directs its own process and tool use). The exam's default answer is to start with the simplest option that works and add autonomy only when the steps genuinely cannot be known in advance.
Go multi-agent only when subtasks are independent enough to run in parallel, or when one context window cannot hold the work. Complexity alone is not a reason: every extra agent adds tokens, latency and a new place for information to get lost.
| Pattern | Use it when | Cost and latency | Failure mode |
|---|---|---|---|
| Prompt chaining | Fixed sequence of steps, each checkable | Low; latency adds up per step | No gate between steps, so errors compound |
| Routing | Distinct input types need different handling | Low; one classification call | Misclassification sends input down the wrong path |
| Parallelization (sectioning) | Independent subtasks can run at once | More calls, lower wall-clock time | Subtasks that secretly depend on each other |
| Parallelization (voting) | You want several attempts and a consensus | N times the cost | Voting on a task with one obviously checkable answer |
| Orchestrator-workers | Subtasks are not known until runtime | Higher; coordinator plus workers | Coordinator loses detail when synthesizing |
| Evaluator-optimizer | Clear criteria and iteration measurably helps | Loops until criteria pass | Never converges without a stop rule |
| Autonomous agent | Open-ended, many steps, trusted environment | Highest and least predictable | Compounding errors without guardrails |
On the exam, watch for "the task is complex, so use multi-agent". The right answer cites independence or context pressure.
Hub-and-spoke orchestration rules
- Subagents inherit nothing. They start with a fresh context and only see what the delegation prompt gives them.
- The delegation prompt carries the goal, the relevant context, the quality bar and the return schema. It does not dictate step-by-step procedures.
- Spawn independent subagents in parallel: several Task (Agent) tool calls in one response, not one per turn.
- Specialists never talk to each other. Everything routes through the coordinator, which owns synthesis.
- Subagents return condensed findings, not raw transcripts, so the coordinator's context stays small.
- Give each specialist a narrow tool set. One agent with 18 tools picks the wrong one more often than four agents with four or five each.
On the exam, watch for a coordinator that passes "research X" with no scope or output format, then complains about overlapping results.
Prompt vs hook: making rules deterministic
If a requirement says must, never, always or audit, the exam expects code to enforce it. Prompts shape behavior; they do not guarantee it. A PreToolUse hook that exits with code 2 blocks the call and feeds its stderr back to Claude, and permission rules (allowedTools, deny rules) remove options entirely.
| Requirement | Prompt instruction | Deterministic control |
|---|---|---|
| Never touch production | "Do not run commands against prod" | PreToolUse hook rejects matching Bash commands (exit 2) |
| Only these tools | "Use only the search tool" | allowedTools least-privilege list, deny rules for the rest |
| Every write is logged | "Remember to log changes" | PostToolUse hook appends to an audit log |
| Normalize tool output | "Ignore extra fields" | PostToolUse hook reshapes the result before the model sees it |
| Refunds over $500 need approval | "Ask before large refunds" | Tool-level check that routes to a human queue |
Session state and escalation
Escalation to a human is a designed path, not a fallback. Define the triggers up front (policy limits, low confidence, repeated tool failure, an explicit customer request) and hand over a structured brief: what was asked, what was tried, the current state, and the decision needed. Dumping the transcript on a human is the anti-pattern.
| Option | What happens | Use it when |
|---|---|---|
Resume (--resume, resume) | Continue an existing session with its full history | Picking up the same thread later |
Fork (fork_session / forkSession) | New session ID that starts from a copy of the history; the original stays intact | Exploring an alternative without losing the main line |
| Fresh session plus summary | New context seeded with a written summary and working files | The old context is bloated or stale |
| Durable working files | Progress notes, todo lists and memory files on disk | Long tasks that outlive any one context window |
Domain 1 anti-patterns
AP-1: Parsing prose to end the loop
Wrong: Stop when the reply contains "task complete"
Right: Stop on stop_reason = end_turn
Text is not a contract; stop_reason is.
AP-2: The iteration cap as the exit
Wrong: Loop until 25 turns, then return
Right: Exit on end_turn; keep the cap as a safety net that alerts
A cap that fires routinely hides a broken loop.
AP-3: One agent, 18 tools
Wrong: Give the generalist every tool
Right: Split into specialists with four or five tools each
Tool selection accuracy drops as overlapping tools pile up.
AP-4: Sequential spawning
Wrong: Spawn one subagent per turn and wait
Right: Issue several Task calls in one response
Independent work should run in parallel.
AP-5: Longer prompts for compliance
Wrong: Add another IMPORTANT paragraph
Right: Enforce with a hook, permission rule or tool check
Prompts are probabilistic; the exam wants determinism for hard rules.
AP-6: Transcript dump at escalation
Wrong: Forward the whole conversation to a human
Right: Send a structured brief with state and the decision needed
Humans need a decision, not a reading assignment.
AP-7: Multi-agent for complexity
Wrong: Complex task, so add agents
Right: Start with one agent or a workflow; add agents for independence or context pressure
Each agent multiplies tokens and coordination cost.
AP-8: Assuming shared memory
Wrong: "The subagent already knows the plan"
Right: Put everything it needs in the delegation prompt
Subagents start with a fresh context.
One-page cheat sheet
Got the sheet? Drill Domain 1 on your phone.
Practice quiz: 12 Agentic Architecture & Orchestration questions
Original, exam-style questions, one per task statement. Pick an answer to see the explanation. Finish all 12 for your score and your weakest topics. No signup.
- Q1When to use subagentsfoundation
Which type of task benefits MOST from being split across parallel subagents?
Answer: D. Read-heavy research where independent sources can be explored simultaneously and each subagent returns a condensed summary
Parallel subagents shine on parallelizable, self-contained, read-heavy work: each worker explores independently in its own context and returns compressed findings. Sequential dependencies eliminate the parallelism benefit, tasks requiring continuously shared state incur heavy coordination overhead, and quick targeted edits are better done in the main conversation because subagents start fresh and add latency.
- Q2Hooks as guardrailsfoundation
What happens when a PreToolUse hook script in Claude Code exits with code 2?
Answer: A. The tool call is blocked, and the hook's stderr output is fed back to Claude as an error message
Exit code 2 from a PreToolUse hook is a blocking error: the tool call is prevented and the stderr text is returned to Claude so it understands why the action was rejected. Stdout, including any JSON, is ignored on exit code 2; JSON decisions like permissionDecision are only processed when the hook exits with code 0. There is no automatic retry behavior for hooks.
- Q3The agentic loopfoundation
Which sequence correctly describes the core loop Anthropic uses to describe how agents operate?
Answer: D. Gather context, take action, verify work, then repeat.
Anthropic describes the agent loop as gathering context, taking action, verifying work, and repeating until the task is done. Classify-and-route describes the routing workflow, not the agent loop, and generate-then-evaluate describes evaluator-optimizer. Planning everything upfront and terminating contradicts the iterative, feedback-driven nature of agents.
- Q4Parallelizationfoundation
Which two variations of the parallelization workflow does Anthropic describe in 'Building effective agents'?
Answer: D. Sectioning, which breaks a task into independent subtasks run in parallel, and voting, which runs the same task multiple times to get diverse outputs.
Anthropic names exactly two parallelization variants: sectioning (independent subtasks in parallel) and voting (the same task run multiple times for diverse outputs). Routing is a separate workflow pattern and gates belong to prompt chaining, not parallelization. Sharding, batching, and map-reduce are general distributed computing terms that Anthropic does not use for this pattern.
- Q5Memory toolfoundation
Which statement accurately describes how the Anthropic memory tool (memory_20250818) executes its file operations?
Answer: A. It is a client-side tool: Claude requests operations such as view and create, and the developer's application executes them against storage the developer controls.
The memory tool operates client-side: Claude only emits tool_use requests, and your application executes each command against its own storage, returning results in tool_result blocks. The /memories path is just a prefix your handler maps onto real storage such as a per-user directory or database keys. Anthropic does not host the files, there is no managed vector database behind it, and it has no dependency on the code execution tool.
- Q6Single-agent vs multi-agentfoundation
Which of the following is a genuine advantage of a single-agent architecture over a multi-agent architecture in production?
Answer: D. Failures are easier to trace and debug because there is one context and one decision-making loop instead of coordination across multiple agents.
With one agent there is a single trajectory to inspect, so debugging and tracing are simpler and cheaper than reconstructing interactions among an orchestrator and multiple subagents. Breadth-first research exceeding one context window is exactly where multi-agent systems excel, single agents remain non-deterministic across runs, and long-running single agents are still stateful systems where errors compound, so observability is still required.
- Q7Autonomy and blast radiusfoundation
According to Anthropic's documentation, in which environment is it appropriate to run Claude Code in bypassPermissions mode?
Answer: D. In an isolated environment such as a container or VM where the agent cannot damage systems that matter
The docs warn that bypassPermissions skips permission prompts and should only be used in isolated environments like containers or VMs where Claude Code cannot cause damage. CLAUDE.md instructions shape model behavior but are not an enforced boundary, so they do not make the mode safe on a workstation. Monitoring a production session does not contain the blast radius of a mistaken action, and git does not protect files outside the repository or actions like network calls.
- Q8Cost and latency tradeoffsfoundation
Which statement best describes the fundamental tradeoff Anthropic identifies for agentic systems compared with a single LLM call?
Answer: B. Agentic systems often trade higher latency and cost for better performance on complex tasks, so teams must evaluate when that tradeoff makes sense.
Anthropic states that agentic systems often trade latency and cost for better task performance, and developers should consider when this tradeoff makes sense. Splitting work across calls increases rather than decreases total tokens and wall-clock time, agents are used precisely because complex tasks demand correctness, and autonomous behavior increases (not removes) the need for evaluation and guardrails.
- Q9Task decompositionintermediate
The lead agent in a multi-agent research system hands subagents short instructions like 'research the semiconductor shortage.' Subagents duplicate each other's work and leave coverage gaps. Based on Anthropic's published lessons, what should each delegation include?
Answer: A. A clear objective, an expected output format, guidance on which tools and sources to use, and explicit task boundaries
Anthropic found that vague delegations cause duplicated work and gaps, and the remedy is detailed task descriptions: an objective, an output format, tool and source guidance, and clear boundaries for each subagent. Adding more workers amplifies the duplication rather than fixing it, peer negotiation is not the documented pattern (the orchestrator owns decomposition), and dumping the full reasoning trace bloats worker context without defining boundaries.
- Q10Session forkingintermediate
Using the Claude Agent SDK, an engineer has a session in which Claude analyzed an authentication module with a JWT approach in mind. They want to explore an alternative OAuth2 design without contaminating the original session's history, which they plan to keep using. What should they do?
Answer: B. Resume the session with the fork session option enabled, which creates a new session ID seeded with a copy of the original history while leaving the original session unchanged.
Forking (resume plus forkSession in TypeScript or fork_session in Python) creates a new session that starts from a copy of the original's history and gets its own session ID, so the original thread remains intact and separately resumable. The continue option simply picks up the most recent session and does not snapshot anything. Renaming transcript files is not a supported branching mechanism, and resuming never reassigns or archives the original session's ID.
- Q11Escalation to humansintermediate
A customer support resolution agent can issue refunds through a tool. The product team wants the agent to stay autonomous for routine cases while avoiding unbounded financial risk. Which design best reflects Anthropic's guidance on agents and human oversight?
Answer: C. Let the agent resolve routine cases autonomously, but have it pause at checkpoints for human approval on high-risk actions, such as refunds above a threshold, or when it encounters blockers.
Anthropic describes agents that pause for human feedback at checkpoints or when encountering blockers, which lets teams gate high-risk actions like large refunds while preserving autonomy for routine resolutions. Approving every message forfeits the scaling benefit of an agent, Anthropic's own support example includes consequential tools like issuing refunds, and temperature is a sampling parameter, not a guardrail against financially risky tool calls.
- Q12Routingintermediate
A support team notices that every time they tune their single prompt to improve refund handling, performance on technical troubleshooting queries degrades, and vice versa. How does adopting the routing workflow address this problem?
Answer: C. It separates concerns by classifying each query and sending it to a specialized prompt, so optimizing one category no longer degrades performance on the others.
Anthropic recommends routing for complex tasks with distinct categories that are better handled separately, precisely because it allows separation of concerns and specialized prompts without one input type's optimization hurting others. Running all prompts in parallel describes parallelization and wastes cost here. Routing needs an accurate classifier, not fine-tuned models, and stuffing all instructions into one prompt is the failure mode the team is already experiencing.
Answer all 12 to see your score
You will get a score and your weakest topics. No signup.
Official sources
Every table on this page was checked against these Anthropic pages in October 2026. When a number here and the docs disagree, trust the docs.