CCAR-F questions and answers — Domain 1: Agentic Architecture

16 practice questions on Agentic Architecture & Orchestration, the domain weighted at 27% of the CCAR-F exam. Every answer explains why the distractors fail — that is the part that transfers to questions you have not seen before.

Question 1

A support agent must never call process_refund before verify_customer has succeeded in the same session. Which design guarantees this?

1. Add three few-shot examples to the system prompt showing verification preceding every refund
2. Add a sentence to the system prompt: 'Always verify the customer before issuing a refund'
3. Implement a PreToolUse hook that denies process_refund unless a successful verification is recorded for the session
4. Set tool_choice to {"type":"tool","name":"verify_customer"} on the first request

Answer: C. Only the hook is an enforcement mechanism. Few-shot examples and system-prompt rules shape behaviour probabilistically — they raise the odds, they do not gate the call. Forcing verify_customer on the first turn does not stop a refund on turn five. This is the single most repeated pattern on the exam: when the stem says 'never' or 'must', look for the programmatic gate.

Question 2

Your agentic loop is terminating early on long tasks, cutting responses mid-sentence. Which check is missing?

1. Handling stop_reason: "max_tokens" as a truncation rather than a completed turn
2. Checking whether the assistant text ends with a full stop
3. Increasing the number of parallel tool calls allowed
4. Setting tool_choice to any

Answer: A. max_tokens means the response was cut off before the model finished. Treating it as a normal completion produces truncated answers and, when a schema is in play, malformed JSON. The fix is to detect it explicitly and either continue the generation or raise max_tokens.

Question 3

A coordinator delegates to a doc-analyzer subagent. Which content does the subagent receive?

1. The parent's full conversation history, so it has complete context
2. Only its own system prompt plus the prompt string passed in the Agent tool call
3. The parent's system prompt and all previously returned tool results
4. Everything the parent has read, minus tool results

Answer: B. A non-fork subagent starts fresh. The Agent tool's prompt string is the only channel from parent to child, which is why every file path, error message and decision the subagent needs must be written into it. It also inherits tool definitions and project CLAUDE.md, but never the parent's history or system prompt. A fork is the exception — it inherits the parent conversation.

Question 4

A research coordinator must gather evidence from three unrelated sources and then synthesise a report. What is the correct execution shape?

1. All four subagents in parallel, then merge whatever arrives
2. Three source subagents in parallel, then the synthesis subagent sequentially on their combined output
3. All four sequentially, so each can refine the previous one's work
4. One general-purpose subagent invoked four times with different prompts

Answer: B. Parallelise what is independent, sequence what has a data dependency. The three retrievals do not need each other; synthesis needs all three. Running synthesis in parallel with retrieval gives it nothing to synthesise, and running the retrievals sequentially makes latency the sum instead of the maximum.

Question 5

A security-scanner subagent fails partway through because its MCP server times out. What should it return to the coordinator?

1. An empty findings array, so the coordinator can continue without special handling
2. A structured error stating what failed, whether it is retryable, and which files were and were not scanned
3. Nothing — let the coordinator's timeout handle it
4. A best-guess list of likely vulnerabilities based on file names it did manage to read

Answer: B. An empty array is indistinguishable from 'scanned everything, found nothing clean' — the coordinator then reports confidence it has not earned. The structured error lets it retry, substitute a scanner, or disclose the coverage gap. Returning nothing loses the same information; fabricating findings is worse than both.

Question 6

Which subagent benefit explains why a codebase-exploration agent that reads 40 files does not bloat the main conversation?

1. Tool restriction
2. Context isolation
3. Specialised instructions
4. Parallelisation

Answer: B. Context isolation. The subagent runs its own conversation; its intermediate tool calls and results stay inside it, and only its final message returns to the parent as the Agent tool result. The other three are real benefits of subagents but describe different mechanisms.

Question 7

An agent explores a legacy codebase to produce a migration plan. It must not modify anything. What is the correct configuration?

1. Give it all tools and instruct it in the prompt to avoid writing
2. Set tools: ["Read", "Grep", "Glob"] in its AgentDefinition
3. Set permissionMode: "plan" and give it all tools
4. Rely on the user approving or rejecting each write

Answer: B. A tool omitted from tools is simply not present in the subagent's session — no prompt, no error, no possibility. Prompt instructions are not a boundary. Plan mode is a reasonable interactive habit but is weaker than removing the capability, and per-write approval does not work for an unattended agent.

Question 8

A customer writes: 'My order is three weeks late AND I was charged twice.' What is the best architecture?

1. Handle issues in the order mentioned, in a single sequential thread
2. Decompose into two parallel tracks with their own tools, then reconcile into one response
3. Escalate immediately to a human, because multi-issue messages exceed agent capability
4. Spawn one subagent per sentence in the message

Answer: B. The two issues are independent — a shipping lookup and a billing investigation — so they parallelise cleanly and reconcile at the end. Sequential handling doubles the latency for no benefit; automatic escalation defeats the first-contact-resolution target; per-sentence decomposition is arbitrary and produces incoherent fragments.

Question 9

Which of these is the correct use of a dynamic workflow rather than turn-by-turn subagent delegation?

1. Any task involving more than one subagent
2. A run coordinating dozens to hundreds of agents, where orchestration should live in a script outside the conversation context
3. Any task where subagents must run in parallel
4. Tasks that require restricting tools per agent

Answer: B. Subagents work well for a handful of delegated tasks per turn. Workflows exist for the scale where turn-by-turn orchestration itself would consume the conversation context — dozens to hundreds of agents driven by a script the runtime executes. Parallelism and tool restriction are ordinary subagent features.

Question 10

You need to stop one prompt from growing into an unbounded tree of agents in a production service. Which combination bounds it?

1. maxTurns alone on the main query
2. A system-prompt instruction not to delegate more than three times
3. CLAUDE_CODE_MAX_SUBAGENT_SPAWN_DEPTH, CLAUDE_CODE_MAX_CONCURRENT_SUBAGENTS, and maxBudgetUsd
4. Setting all subagents to a cheaper model

Answer: C. Three independent limits: how deep nesting goes, how many run at once, and how much the query may spend. A prompt instruction only steers. maxTurns bounds one agent's turns, not the tree. A cheaper model reduces unit cost without bounding the growth.

Question 11

What decides whether Claude automatically invokes your performance-optimizer subagent?

1. The prompt field of its AgentDefinition
2. The description field of its AgentDefinition
3. Its position in the agents object
4. Whether its tools list overlaps the task

Answer: B. description is the routing signal — a natural-language statement of when to use this agent. prompt defines behaviour once invoked. If Claude is not delegating, sharpen the description or name the agent explicitly in your prompt.

Question 12

A coordinator sends every incoming request through all six specialist subagents 'so nothing is missed'. What is the primary architectural objection?

1. Subagents cannot run in parallel at that count
2. It multiplies cost and latency and dilutes synthesis with irrelevant findings
3. Subagents cannot share a tool set
4. The Agent tool has a hard limit of four subagents

Answer: B. Routing is the coordinator's job. Fanning out unconditionally pays six times for one answer, makes latency the slowest of six, and forces the synthesis step to filter noise it should never have received. There is no four-agent limit, and the other objections are fabricated.

Question 13

In the SDK, how do you detect that a message originated inside a subagent's execution rather than the main conversation?

1. The message has a non-null parent_tool_use_id
2. The message role is system
3. The message contains a subagent content block
4. You cannot — subagent messages are not streamed

Answer: A. Messages from within a subagent carry the ID of the Agent tool call that spawned them in parent_tool_use_id; main-conversation messages carry null. Invocation itself is detected by a tool_use block named Agent (historically Task — match both for version safety).

Question 14

A subagent stops at its maxTurns limit with the work half-done. What is the correct recovery?

1. Start a new subagent with the same prompt and hope it is faster
2. Resume the subagent using its agentId within the resumed session, preserving its full history
3. Increase maxTurns and re-run from scratch
4. Fall back to the built-in general-purpose agent

Answer: B. Output is returned marked partial, and the Agent tool result carries agentId: <id>. Capture the session_id, resume that session, and reference the agent ID — the resumed subagent retains all prior tool calls, results and reasoning. Restarting throws away work you have already paid for.

Question 15

An open-ended request — 'work out why our checkout conversion dropped' — is best handled by which agent design?

1. A fixed five-step pipeline covering the most common causes
2. Adaptive decomposition: investigate, then decide the next step from what was found
3. One subagent per hypothesis, run in parallel from the start
4. Escalating to a human, since the task is under-specified

Answer: B. The shape of this task is unknown until you look. A fixed pipeline investigates the wrong things thoroughly; parallel hypothesis agents commit to a hypothesis set before any evidence exists. Adaptive decomposition — gather, then branch — is the agentic pattern, with parallelism introduced once independent lines of enquiry are actually identified.

Question 16

Which statement about the built-in general-purpose subagent is correct?

1. It must be declared in agents before Claude can use it
2. Claude can invoke it through the Agent tool without you defining any agents
3. It has no tool access by default
4. It is the only subagent that can be resumed

Answer: B. When Claude calls the Agent tool without a subagent_type, it gets the built-in general-purpose agent, available with no definition of your own. If you need that off — for a locked-down harness — the environment variable CLAUDE_AGENT_SDK_DISABLE_BUILTIN_AGENTS=1 removes it, and such a call then fails.

← Previous: Cheat sheet  |  Next: Questions & answers — Domain 2 →