CCAR-F practice questions: Agentic architecture.

A support desk needs incoming tickets sorted into five fixed categories and routed to the matching queue. Which design fits best?

• An evaluator-optimizer loop that proposes a category and revises it until a second judge call agrees
• A single autonomous agent with the queue tools attached, deciding per ticket where it should go
• A routing workflow with one classification call, then a fixed handoff to the queue for that category
• An orchestrator that spawns five subagents and lets each one claim the tickets it judges to be in scope

A task requires editing an unknown number of files across a repository, and the set of files cannot be predicted until the work is under way. Which pattern applies?

• Parallelization with a worker per file type, each scanning its share of the tree for changes to make
• Prompt chaining with one step per directory, so every part of the repository gets its own fixed pass
• Orchestrator-workers, with a coordinator that discovers the subtasks during the run and delegates each one
• A single call with the full repository loaded into context, asking the model to return every edit in one response

A translation pipeline produces drafts that a reviewer can grade against clear criteria, and quality improves when feedback is applied. Which pattern matches?

• Routing by language pair, so each pair reaches a specialist prompt tuned with curated examples for that pair
• Parallelization across sentences, with each worker translating a slice and a final merge step
• Evaluator-optimizer, where one call drafts, a second grades against the criteria, and the loop repeats
• A single agent with a translation tool that it calls once per document and returns the result

An agent can issue refunds. The business wants any refund above $500 approved by a person. Where should that rule live?

• In a permission check or hook that intercepts the refund tool call and blocks it until a person approves
• In a weekly review of the refund log, so any refund over the limit is caught and reversed if it turns out to be wrong
• In the system prompt, as a rule telling the model to pause and ask before any refund above the limit
• In the refund tool's description, so the model reads the threshold every time it considers the tool

A tool that creates invoices sometimes times out, and the agent retries. Customers are receiving duplicate invoices. Best fix?

• Make the tool idempotent with a client-supplied request id, so a repeated call returns the same invoice
• Raise the tool's timeout so that slow invoice runs finish before the agent loop gives up on the call and retries
• Add a system prompt rule that the model should retry only after checking the invoice list first
• Move invoice creation out of the tool and into a post-run batch job that dedupes by customer

During a long multi-agent run one tool starts returning errors on every call, and the coordinator keeps re-issuing the same request. What is missing?

• A stronger model for the coordinator role so it notices the pattern and changes its approach
• A larger context window for the coordinator so the earlier error results stay visible to it
• Bounded retries with backoff and a circuit breaker that stops calling the tool after repeated failures
• A system prompt instruction telling the coordinator to switch to a different tool as soon as it sees an error result

A document pipeline runs the same three steps on every input: extract entities, normalize them, then write a summary. Each step's output feeds the next. Which pattern is this?

• Orchestrator-workers, with a planner assigning steps
• Evaluator-optimizer over the summary step
• Parallelization, with the three steps run at once
• Prompt chaining, with each output feeding the next

Three independent checks (toxicity, PII, and policy) must run on every response before it is shown. Latency matters. Which pattern?

• Have one classifier call decide which checks are needed
• Fold all three checks into a single call with one prompt
• Chain the checks in sequence so each one sees the previous verdict
• Run the three checks concurrently and aggregate the verdicts

When does Anthropic's guidance say to reach for an agent instead of a workflow?

• When the task is large enough that a single prompt cannot hold all of the input
• When the number of steps cannot be predicted and the model must choose its path from results
• When latency is not a concern and the budget comfortably allows several model calls for each request
• When the steps are known in advance but each step needs a different model

An agent for booking travel has succeeded in demos but sometimes loops forever in production. The most important missing control is:

• A maximum turn count and a stop condition the loop checks on every iteration
• A larger context window so earlier attempts remain visible and are not repeated
• A wider tool set so the agent has an alternative route when one provider fails
• A more detailed persona and goal statement so the agent stays focused on the booking

Which is the strongest reason to start a new client project with workflows rather than agents?

• Workflows can be built without prompt engineering, so the client's own team can maintain them
• Workflows are what stakeholders expect and are easier to present in a demo
• Workflows are predictable, testable, and cheaper, building the trust needed before autonomy
• Agents require the Agent SDK, which most client environments cannot run

An orchestrator delegates research to three subagents and then writes a report. One subagent returns nothing useful. What should the design do?

• Drop that topic from the report and note in the log that the subagent returned no content
• Hand the empty topic back to the user with a question about whether the report should continue
• Detect the gap, retry or re-scope the subtask, and proceed with what it has when retries run out
• Fail the whole run and surface the empty result, since a partial report could mislead whoever reads it

A coding agent must never run a destructive git command. Which enforcement is reliable?

• A CLAUDE.md section describing which git operations are off limits in this repo
• A PreToolUse hook or permission rule that blocks matching commands before they execute
• A lower temperature setting so the agent sticks to the conservative commands it has already seen
• A system prompt rule listing every destructive git command the agent must not run

You are asked to justify why an agent design uses a single coordinator instead of a swarm of peer agents that message each other freely. The best justification:

• Peer messaging is slower in practice because every message needs its own model call
• A coordinator keeps control flow observable and debuggable, and bounds each subagent's context
• Peer agents cannot share tool results, so a coordinator is needed to relay them
• The API's multi-agent support is built around a single coordinator, so peer swarms need extra scaffolding

A customer wants an agent that autonomously sends emails on their behalf. What belongs in the first release?

• Autonomous sending for all emails except the ones the model itself flags as sensitive
• Draft-then-approve: the agent prepares emails and a person sends, with autonomy earned on measured accuracy
• Autonomous sending for internal recipients only, expanding to external once a week has passed
• Full autonomy from day one, with a daily audit of what was sent so problems are caught early

Which metric best tells you an agent is worth its cost in production?

• Average tokens consumed per completed task, trended week over week
• Number of tasks handled per day compared with what the human team handled before
• Task completion rate at acceptable quality, measured per dollar and per minute
• Share of runs that finish without any tool errors or retries

An evaluator-optimizer loop keeps running for many iterations without converging. What is the likely design flaw?

• The evaluator's criteria are vague, so 'good enough' is never reached; it needs pass criteria and a round cap
• The loop has no memory of earlier drafts, so it keeps repeating the same corrections
• The generator runs at too high a temperature, so each draft moves in a new direction
• The evaluator and generator share a prompt, so the judge is biased toward its own output

A routing workflow classifies requests into billing, technical, and sales. Ten percent of requests fit none. What should the design include?

• A fourth category learned from the unclassified requests after launch
• Retry classification with a second model until every request lands in one of the three
• A fallback route for 'other' that goes to a general handler or to a person
• A confidence threshold that forces low-confidence requests into the nearest bucket

Which statement about tools in agent loops is correct?

• Tools must be called in the order they are listed, so ordering in the tools array matters
• Tool results are data the model reasons over; instructions come from the system prompt and user
• Tool results can only carry text, so binary or structured data must be described in the prompt
• Tool results should be passed back as a user turn so that the model treats them as fresh instructions to follow

A team wants to run twenty subagents in parallel for a research task. What should they watch first?

• That each subagent has a complete, self-contained brief and a bounded budget
• That every subagent uses the same tool set so the results have a common shape
• That the coordinator holds no context of its own and only merges the results
• That all subagents share one context window so they do not duplicate work

An agent must decide between continuing a task and asking the user a question. Good design says it should ask when:

• Any tool call in the current step has returned an error
• It has consumed half of its token budget for the task at hand
• It has finished one subtask and the next one on the list belongs to a different owner
• The next action is irreversible, ambiguous, or outside its granted scope

A workflow uses one large model call to do classification, extraction, and a summary at once, and quality is uneven. What is the usual improvement?

• Decompose into chained steps so each call has one job and can be checked
• Drop the summary from the call and generate it separately with a template
• Switch to a larger model so it can handle the three tasks in one pass
• Enable extended thinking so the model plans all three outputs before writing

What is the practical reason to log every tool call, its inputs, and its result in an agent system?

• Cost control, since tool call logs are the only way to reconstruct token usage per task
• Prompt caching, since logged calls can be replayed as a cached prefix on the next run
• Debugging, evaluation, and audit: you cannot improve or explain behavior you did not record
• Compliance reporting, since most regulated industries require a record of automated actions

A client says 'make it fully autonomous' for an agent that changes production database records. Your recommendation as the architect:

• Full autonomy as requested, with a nightly database backup so any bad change can be restored
• Full autonomy with logging turned off in the hot path so approval latency does not slow the agent
• Read-only access for the agent, with all writes handled by a separate scheduled job the client owns
• Autonomy for reads and reversible changes, approval for irreversible ones, with an audit trail, revisited as data comes in

A due-diligence agent must read 300 contracts and produce one risk table. Which structure keeps quality consistent?

• Load all 300 contracts into one long context and ask for a single risk table in one pass
• Fan out one worker per contract with the same extraction brief and schema, then merge the structured results
• Route each contract by type to a specialist prompt and let each specialist write its own section of the table
• Chain the contracts sequentially so each worker sees the previous worker's risk rows before extracting its own

What is the main cost of adding a 'reflection' step where the agent critiques its own output before returning it?

• Added tokens and latency, so it pays off where errors are expensive and the criteria are checkable
• It blocks tool use during the critique turn, so agents that rely on tools cannot use reflection safely
• It only works with a larger model as the critic, which doubles the cost of every task in the pipeline
• The critique tends to anchor on the draft, so it should replace the generator rather than follow it

An agent is allowed to call a payments API. Which control is non-negotiable?

• An evaluator model that reviews each proposed payment call and rejects any that look unusual
• An enforced gate outside the model that requires approval or applies limits before the call executes
• A system prompt instruction to confirm the amount with the user before every payment call
• A detailed tool description that lists the payment limits so the model knows when to refuse a transfer

Which sign suggests a workflow should be split into two chained model calls?

• The task takes several seconds per run, and latency matters more than accuracy for this use case
• The prompt calls a single tool several times per run, and each call returns a large result
• One prompt both extracts facts and writes persuasive prose, and one of those two keeps degrading
• Outputs are short and consistent, but the prompt is longer than the team would like to maintain

A team runs an agent that reads email and drafts replies. A client asks why it never sends automatically. Best answer?

• Autonomous sending would break prompt caching because each sent message changes the conversation prefix
• The Messages API has no outbound email capability of its own, so a person has to press send in the mail client each time
• Sending is irreversible and public, so it stays gated by a person until measured accuracy earns more autonomy
• The agent runs in a workflow rather than an agent loop, and workflows cannot trigger external actions

What distinguishes routing from an orchestrator in the workflow patterns?

• Routing requires a separate model per path, while an orchestrator uses one model for every subtask
• Routing sends an input down one of several fixed paths; an orchestrator plans dynamic subtasks and synthesizes results
• Routing runs several fixed paths in parallel and merges their outputs; an orchestrator runs the same paths one after another and keeps the best
• Routing is a form of parallelization; an orchestrator is a form of evaluator-optimizer loop

An agent produced a correct answer but took 40 tool calls where 5 would do. Which lever addresses this?

• Sharper tool descriptions, an explicit plan step, and a per-task call budget with feedback as it nears the limit
• Cut the tool list down to the two or three tools the task used most, so there is less to choose from and fewer wrong turns
• Switch to parallel tool calls so the 40 calls complete in the time five sequential ones would take
• Lower the context window by trimming the system prompt so the model has less to reason over each turn

Why should a subagent's brief include the success criteria and the expected return format?

• So the coordinator can reuse the subagent's full transcript as context for later steps instead of a lossy summary
• So the subagent knows when to stop and the coordinator can merge results without re-reading transcripts
• So the subagent can skip tool calls and answer from the brief alone, saving tokens
• Because the Agent SDK rejects a subagent definition that has no output schema attached

A stakeholder asks for 'an AI that runs the whole department'. As the architect, the first design move is:

• Build one general agent with every department tool attached and let it learn the workflows from use
• Start with an orchestrator-workers system so each function of the department gets its own dedicated worker agent
• Map the workflows, classify steps by predictability and blast radius, and start with the predictable ones
• Pick the most capable model available so the agent can handle whatever the department throws at it

Which is the correct role of an evaluator in an evaluator-optimizer loop?

• Produce the first draft, then revise it against the same criteria in a single turn
• Decide which tools the generator may call on its next attempt at the task
• Summarize the generator's transcript so the loop fits in the context window
• Judge the draft against explicit criteria and return specific, actionable feedback

An agent needs to process items that arrive continuously over a day. What design fits?

• A single batch prompt at the end of the day that processes all items together in one call
• One long-running session that keeps every item in context so it can spot patterns across the day
• A queue-driven loop that handles each item in a fresh bounded context and persists state between items
• An orchestrator that spawns a subagent per item and keeps every subagent transcript for the coordinator

What is the practical reason to make agent steps observable with structured logs rather than free-text notes?

• Structured logs can be queried, rolled into metrics, and replayed for evaluation
• The model produces more consistent reasoning when it is asked to log in a structured format
• Free-text notes consume more tokens per step, so structured logs keep the run inside the context budget
• Structured logs are required for prompt caching to work across steps of the run

A coordinator receives conflicting answers from two subagents. Sound handling?

• Take the answer from whichever subagent used more tool calls, since it did more research
• Merge both answers into one combined response and let the downstream consumer decide which parts to trust
• Detect the conflict, resolve it with a defined rule or a verification step, and record the decision
• Rerun both subagents with the same brief and accept the answer that appears more often

Which situation calls for human-in-the-loop by design rather than by exception?

• Any step where the model reports low confidence in its own answer partway through the run
• Approving legal commitments, spending above a threshold, or changes to people's records
• Steps where two workers in a parallel fan-out return different formatting
• Every tool call that reads from a production database rather than a staging copy

What is the risk of letting an agent modify its own instructions during a run?

• The run costs more because each instruction rewrite invalidates the cached prompt prefix
• There is little risk if every instruction change is logged, since the log lets you replay the run afterward
• Drift and loss of control; standing instructions should be fixed, versioned, and changed by people
• The agent becomes slower to complete tasks because it spends turns editing its own prompt

A workflow's third step frequently fails on malformed input from step two. Best fix?

• Validate step two's output against a schema before step three runs, with a repair path on failure
• Merge steps two and three into one prompt so there is no boundary for malformed data to cross
• Wrap step three in a retry loop with backoff so transient formatting problems resolve themselves
• Ask step three to tolerate malformed input by instructing it to do its best with whatever arrives

A nightly job classifies 50,000 support tickets into one of eight categories. Which architecture is right?

• One agent with the full ticket export in context so it can spot category patterns
• An autonomous agent per ticket with tools to look up the customer's history before deciding
• An orchestrator that spawns one classifier subagent per category and lets them vote on each ticket
• A batch workflow with a fixed prompt and schema-constrained output, plus a sampled human audit

Which question best decides whether a task needs an agent at all?

• Can the steps be written down in advance, or does the path depend on what the model finds along the way?
• Is the budget large enough to absorb the extra tokens that an agent loop consumes?
• Does the task involve tools, since tool use is what distinguishes an agent from a prompt?
• Is the model capable enough to complete the task end to end without a human checking each intermediate step?

An agent's outputs are correct but users complain it 'never explains why'. What is the low-cost design fix?

• Enable extended thinking and return the thinking blocks to users as the explanation
• Ask for a brief rationale alongside the structured result, kept separate from the machine-readable fields
• Add a second model call that reads the result and writes an explanation for the user
• Drop the structured output and return prose so the reasoning and the answer arrive together in one readable block

Two subagents produce partial reports and the coordinator must merge them into one document. What protects merge quality?

• A fixed output schema for the partials so merging is deterministic, then one editing pass for coherence
• Run the two subagents sequentially so the second one extends the first one's document
• Let the coordinator read both partials in full and improvise a merged document
• Have each subagent read the other's draft before finishing so the two partials already agree on structure and content

Which is the right response when an agent's evaluator step disagrees with a human reviewer 30% of the time?

• Average the evaluator's score with the human's so neither judgment dominates the outcome
• Trust the evaluator, since consistent model judgments beat a single reviewer's opinion
• Calibrate the evaluator against the human labels, refine its criteria, and keep the human until agreement is high
• Replace the evaluator with a second human reviewer, since a 30% disagreement rate shows model grading does not work here

A client wants the agent to run overnight unattended. Which capability must exist first?

• Extended thinking on every turn so the agent reasons carefully without supervision
• A hard stop on cost and turns plus alerting, so an unattended run cannot spiral
• A dashboard showing live progress so the team can check on it in the morning
• A larger model, so the run makes fewer mistakes when nobody is there to correct it

What does 'fail closed' mean for an agent that hits an unexpected error?

• Stop the action, record the state, and hand off to a person or a defined fallback
• Retry the failing step with a different tool until one of them succeeds
• Continue with the most likely interpretation and flag the guess in the final report
• Restart the whole task from the beginning with a fresh context and the same inputs

An orchestrator-workers design is producing repeated work across workers. Likely cause?

• Too few workers, so each one is covering more of the task than it can hold in context
• Overlapping subtask briefs; the coordinator should partition the task so each worker's scope is disjoint
• Missing evaluator step, so duplicate outputs are never caught before the merge
• The workers share one context window, so each one sees the others' progress and repeats it in its own output

Which metric would you add to detect that an agent is 'succeeding' by giving up early?

• Task completion checked against explicit acceptance criteria, not the model reporting done
• Tool calls per task, since an agent that stops early makes fewer calls than expected
• Latency per task, since early exits finish faster than runs that do the whole job
• Average tokens per task, since a run that gives up early uses noticeably fewer tokens than a full run

A workflow needs a human to approve step three only when the amount exceeds a threshold. How do you model it?

• Instruct the model to decide when the amount seems high enough to ask a person
• Require approval on every run of step three, since a threshold check adds complexity
• A conditional gate in the workflow that routes to a human queue when the condition holds
• Have an evaluator model review step three's output and escalate whenever the amount looks risky

Which practice keeps agent behavior reproducible enough to debug?

• Logging the exact prompts, tool inputs and outputs, and model settings per step
• Using the largest model, since stronger models behave more predictably
• Turning off prompt caching so each step is computed fresh from the raw prompt
• Setting temperature to zero, which makes each run identical for the same input and settings

A stakeholder asks why the agent needs a 'planning' step that costs extra tokens. Best answer?

• It makes the model look more deliberate, which builds stakeholder confidence in the output even when the plan is not followed
• The Agent SDK requires a planning turn before any tool call can be executed in a session
• Plans are cached as part of the prompt prefix, so every later turn in the same run costs less per token than the first
• On multi-step tasks a plan cuts wasted tool calls and lets people review intent before actions, usually saving more than it costs