20 Agentic Architecture & Orchestration Practice Questions & Answers

1. 1. A support team's email triage step must label each inbound message with one of five categories. An offline evaluation shows that a single well-specified prompt containing the five category definitions reaches 96% accuracy, matching the human baseline. An architect proposes replacing it with an agent that has search and lookup tools and decides its own steps. What is the best assessment?

   • A.Move to an agent because production inputs are always messier than evaluation sets and agents degrade more gracefully
   • B.Keep a single call but wrap it in a loop so the model can revise its own label until it reports high confidence
   • C.Keep the single model call; the task is fully specifiable in advance, so added autonomy buys nothing and adds cost, latency, and output variance✓ Answer
   • D.Move to an agent so the classifier can pull account history and push accuracy beyond 96%

   The ladder of approaches runs from a single model call, to a code-orchestrated workflow, to an open-ended agent, and the default is the simplest tier that meets the requirement. A closed-set classification whose criteria are fully written down needs no runtime decision-making, so autonomy adds cost, latency and non-determinism with no accuracy mechanism behind it. Self-reported confidence is also a poor control signal, since the model is confidently wrong precisely on the hard cases.

   Source: Anthropic Engineering, "Building Effective Agents" — start with the simplest solution and add complexity only when it demonstrably improves outcomes; Anthropic Claude certification (Architect – Foundations), Domain 1Report a problem with this question

2. 2. A document intake pipeline has four steps that are always the same and always run in the same order: extract text, normalize field formats, validate against a schema, and route to a queue. Each step's output can be checked programmatically. The team proposes building an open-ended agent that decides which step to run next. What should the architect recommend?

   • A.Use one model call that performs all four steps in a single response to minimize latency
   • B.Build the agent but constrain it with a system prompt that lists the four steps in the required order
   • C.Build the agent; letting the model choose the order makes the pipeline resilient to document types nobody has seen yet
   • D.Implement it as a code-orchestrated workflow (prompt chaining) with programmatic gates between steps, because the sequence is known in advance✓ Answer

   Agents earn their overhead when the steps cannot be specified in advance; here they can, so a fixed chain is the right tier. Prompt chaining also lets the harness insert deterministic gates between stages, so a bad extraction is caught before the schema check ever runs. Listing the steps in a system prompt is only probabilistic guidance — the harness, not the model, should own the ordering guarantee.

   Source: Anthropic Engineering, "Building Effective Agents" — prompt chaining for tasks decomposable into fixed sequential subtasks; Anthropic Claude certification (Architect – Foundations), Domain 1 (task decomposition)Report a problem with this question

3. 3. A proposed agent would file compliance submissions to an external regulator. Once submitted, a filing cannot be retracted, and mistakes surface only weeks later when the regulator responds. Evaluation shows the model drafts the filings well. How should the system be designed?

   • A.Keep drafting autonomous but require a human confirmation gate before submission, because the criterion that errors be detectable and recoverable is not met✓ Answer
   • B.Ship full autonomy and add automatic retries on tool errors, which covers the failure mode
   • C.Abandon the project; any task with irreversible external effects is unsuitable for model involvement
   • D.Ship full autonomy but instruct the agent in its system prompt to double-check the filing before submitting

   One of the four criteria for granting an agent autonomy is that errors must be catchable and recoverable; a filing that cannot be retracted and whose errors surface weeks later fails that test. The correct response to a failed criterion is not to abandon the task but to move the boundary of autonomy: let the agent do the recoverable part (drafting) and place a human checkpoint immediately before the irreversible step. Retries only address transient tool failures, and prompt-level self-checking is probabilistic, so neither restores recoverability.

   Source: Anthropic Engineering, "Building Effective Agents" — criteria for agent suitability, including error detection and recovery; Anthropic Claude certification (Architect – Foundations), Domain 1 (human-in-the-loop checkpoints)Report a problem with this question

4. 4. About 70% of a support agent's traffic is one trivial intent: "send me a password reset link." Handling it through the full agent loop costs roughly 40x a templated response and adds about 30 seconds of latency, and resolution quality is identical either way. What is the most defensible architecture?

   • A.Keep everything in the agent; per-interaction cost and latency are operational concerns, not architectural ones
   • B.Keep everything in the agent but cap it at a single tool call for that intent
   • C.Route that intent to a deterministic templated path and reserve the agent loop for intents where reasoning actually changes the outcome✓ Answer
   • D.Keep everything in the agent for a consistent conversational experience and cut cost by shortening the system prompt

   A second criterion for agent suitability is that the value of autonomy must justify its cost and latency; on an intent whose outcome is identical either way, that ratio is indefensible at 70% of volume. Routing the high-volume deterministic intent away from the loop is the standard remedy and leaves the agent's budget for cases where reasoning changes the answer. Trimming the prompt or capping tool calls shaves the symptom while still paying the loop's overhead for work that never needed a loop.

   Source: Anthropic Engineering, "Building Effective Agents" — agents trade cost and latency for autonomy; Anthropic Claude certification (Architect – Foundations), Domain 1 (autonomy tradeoffs)Report a problem with this question

5. 5. In evaluation, an agent asked to modify code in a rarely used legacy language succeeds on roughly 35% of tasks and produces plausible-looking but incorrect changes on the rest, with no drop in its stated certainty. The team plans to give it more tools and a much higher iteration limit. What should the architect say?

   • A.More autonomy cannot close a capability gap; narrow the agent's scope to subtasks it demonstrably handles, such as locating and summarizing code, and keep the edits under human authorship✓ Answer
   • B.Have the agent emit a confidence score and auto-accept only the changes above a threshold
   • C.Add an evaluator-optimizer loop that uses the same model as the evaluator, so wrong changes are caught automatically
   • D.Raise the iteration limit so the agent has more turns to self-correct its way to a working change

   The third criterion is whether the model is actually capable at this task type; when it is not, extra loops amplify a low base rate rather than repair it. An evaluator drawn from the same model shares the blind spot that produced the error, and a self-reported confidence score is uncalibrated exactly where it matters. The durable move is to re-scope the agent onto subtasks where measured performance is strong and keep the unreliable step under human authorship.

   Source: Anthropic Engineering, "Building Effective Agents" — model capability at the task type as a precondition for agent autonomy; Anthropic Claude certification (Architect – Foundations), Domain 1Report a problem with this question

6. 6. An engineer's agent loop terminates when the assistant's text contains "done" or "finished." Production logs show about 12% of runs stop while tool calls are still outstanding, while other runs keep looping after the work is complete. What is the correct fix?

   • A.Expand the terminator vocabulary and add a regular expression that catches paraphrases of completion
   • B.Ask the model to emit a JSON sentinel object inside its text on the final turn and parse that string instead
   • C.Lower the iteration cap so runs cannot over-loop, and treat cap exhaustion as ordinary completion
   • D.Drive termination from the structured stop signal returned with each model response — continue while the model has requested tool use, stop when it ends its turn✓ Answer

   In an agentic loop the model proposes actions and the harness executes them, so the harness must key its control flow on the structured stop signal the API returns, not on prose the model happened to write. Text matching is unreliable in both directions: prose can announce completion while a tool call is still pending, and completion can be phrased in ways no pattern anticipates. An iteration cap is a safety backstop, not a termination mechanism, and treating cap exhaustion as success hides truncated work from every downstream consumer.

   Source: Anthropic Engineering, "Building Effective Agents" — the agentic loop runs until a structured stopping condition; Anthropic Claude certification (Architect – Foundations), Domain 1 (agentic loop lifecycle)Report a problem with this question

7. 7. Policy caps agent-issued refunds at a fixed threshold, above which a human must approve. The threshold is stated plainly in the system prompt, yet audit sampling still finds a small but persistent share of refunds issued above it. What is the most effective remedy?

   • A.Require the agent to state the amount and its own compliance judgment in the turn before it calls the tool
   • B.Enforce the cap in the harness by intercepting the refund tool call and rejecting or rerouting anything above the threshold, since prompt guidance has a non-zero failure rate✓ Answer
   • C.Restate the cap at both the top and bottom of the system prompt and add few-shot examples of correctly refusing an over-threshold refund
   • D.Log each violation and address the pattern through weekly prompt tuning based on the audit findings

   Responsibility in an agentic loop splits cleanly: the model proposes, the harness executes and therefore owns policy enforcement. Any instruction expressed in a prompt is probabilistic and will fail some fraction of the time, which is unacceptable when the requirement is guaranteed compliance. Intercepting the tool call makes the violation structurally impossible rather than merely unlikely, and the same logic rules out asking the model to audit itself.

   Source: Anthropic Claude certification (Architect – Foundations), Domain 1 — programmatic enforcement versus prompt-based guidance when deterministic compliance is requiredReport a problem with this question

8. 8. A localization workflow must, for every product description: translate it, then adapt units and currency conventions, then verify no claim was added or dropped. Each stage's output is a clean input to the next, and a programmatic check between stages can catch failures early. Which pattern fits best?

   • A.A single call performing all three, because chaining multiplies latency without any accuracy benefit
   • B.Orchestrator-workers, so the model can decide at runtime which of the three stages a given description needs
   • C.Parallelization: run the three stages simultaneously and merge their outputs at the end
   • D.Prompt chaining: fixed sequential calls with a programmatic gate between stages, since the decomposition is known and each step is easier in isolation✓ Answer

   Prompt chaining is the pattern for work that decomposes into a known sequence where each call's output feeds the next; it trades a little latency for higher accuracy on each simpler subtask and creates natural points for programmatic gates. The stages here are genuinely dependent, so parallelization is not available — the claim check cannot run before the text exists. Orchestrator-workers is reserved for cases where the subtasks cannot be enumerated in advance, which is not true of a fixed three-stage pipeline.

   Source: Anthropic Engineering, "Building Effective Agents" — prompt chaining, with programmatic checks ("gates") between stepsReport a problem with this question

9. 9. Inbound support messages fall into distinct families — refunds, technical faults, billing disputes — each needing different tools and a different tone. One combined prompt covering all of them has grown long and now measurably underperforms the earlier single-family prompts on every family. What is the right structural change?

   • A.Replace it with an open-ended agent that composes a handler for each message at runtime
   • B.Run all three specialized prompts in parallel on every message and have a final call pick the best answer
   • C.Split the combined prompt into labeled sections and instruct the model to read only the section matching the message
   • D.Add a routing step that classifies the message and dispatches it to a specialized prompt and scoped tool set per family✓ Answer

   Routing is the workflow pattern for heterogeneous inputs that fall into recognizable categories requiring different handling; classifying first lets each downstream prompt stay narrow and keeps optimization of one family from degrading another. Sectioning a single prompt still loads all instructions into one context and preserves the interference. Fan-out to all three handlers pays triple cost on every message, and an open-ended agent adds runtime decision-making to a problem whose categories are already known.

   Source: Anthropic Engineering, "Building Effective Agents" — routing for heterogeneous inputs handled better by specializationReport a problem with this question

10. 10. A research coordinator must gather evidence for six independent subtopics that do not depend on one another's results. It currently issues them one at a time; end-to-end latency is about nine minutes and output quality is acceptable. What change best addresses the latency?

    • A.Merge the six subtopics into one broad query so only a single search is needed
    • B.Keep it sequential; concurrent subagents share context and would contaminate one another's findings
    • C.Issue the six subtopic delegations concurrently within a single coordinator turn, then synthesize once all results return✓ Answer
    • D.Cut scope to the three most important subtopics so the run fits the latency target

    Parallelization by sectioning applies exactly when subtasks are independent, and the coordinator realizes it by emitting the delegations together in one response rather than across successive turns. Subagents run with isolated context, so concurrency causes no cross-contamination — the premise of the third option is simply false. Collapsing six subtopics into one query trades away the coverage the parallel structure exists to provide, and cutting scope solves latency by not doing the work.

    Source: Anthropic Engineering, "Building Effective Agents" — parallelization (sectioning) for independent subtasks; Anthropic Claude certification (Architect – Foundations), Domain 1 (parallel subagent invocation, isolated subagent context)Report a problem with this question

11. 11. A security review pass catches most injection defects, but each individual run misses a different subset. The business requirement is high recall: a missed defect is far costlier than a false positive a reviewer discards in seconds. Which design best serves that requirement?

    • A.Run a single pass over a much larger combined input so that no file is out of scope
    • B.Run a single pass and have the model rate its own confidence, reporting everything above a threshold
    • C.Run several independent passes with different prompt framings and report the union of their findings, deduplicated✓ Answer
    • D.Run three passes and report only the findings on which at least two passes agree

    Parallelization can be used for reliability, but how you aggregate must match the asymmetry of the error costs: when misses are expensive and false positives are cheap, take the union. Majority voting is the aggregation for the opposite asymmetry and would actively suppress the real defects that only one pass happens to catch. Enlarging the input dilutes attention across files rather than improving recall, and self-rated confidence is not a calibrated signal.

    Source: Anthropic Engineering, "Building Effective Agents" — parallelization for voting/reliability; Anthropic Claude certification (Architect – Foundations), Domain 4 (consensus voting suppresses intermittently detected true findings)Report a problem with this question

12. 12. A change request reads: "remove the deprecated date helper everywhere and replace it with the new one." Which files are affected, and how many distinct call patterns exist, cannot be known until the codebase has been analyzed. Which pattern fits?

    • A.Prompt chaining, with one step per affected file defined before the run begins
    • B.Routing, with one branch per file extension present in the repository
    • C.A single long call over the whole repository so the model can see every usage at once
    • D.Orchestrator-workers: a central call analyzes the codebase and then dynamically spawns a worker per discovered call site, because the subtasks cannot be enumerated in advance✓ Answer

    Orchestrator-workers is the pattern whose defining condition is that the subtasks depend on the input and cannot be predicted before the work starts; a central model determines the decomposition at runtime and delegates the pieces. Prompt chaining requires the steps to be fixed in advance, which is precisely what is unknown here, and routing addresses category selection rather than dynamic decomposition. A single call over the whole repository suffers attention dilution and gives no per-site verification point.

    Source: Anthropic Engineering, "Building Effective Agents" — orchestrator-workers for tasks whose subtasks cannot be predicted in advanceReport a problem with this question

13. 13. Generated release notes must satisfy a written rubric: every user-visible change covered, no internal ticket IDs, plain language. Reviewers consistently observe that a second draft written against specific rubric feedback is markedly better than the first. Which pattern should the architect use?

    • A.A single call with the rubric appended, since iteration mostly adds cost
    • B.Parallel drafting of several versions, keeping the longest and most detailed one
    • C.An evaluator-optimizer loop: one call drafts, a second scores against the rubric and returns concrete feedback, the draft is revised, all bounded by a fixed iteration limit✓ Answer
    • D.An open-ended agent with repository tools that decides for itself when the notes are good enough

    Evaluator-optimizer applies when there are clear evaluation criteria and iteration measurably improves the result — both conditions are stated here. The loop must be bounded so a rubric that can never be fully satisfied cannot spin indefinitely. Letting the agent judge its own sufficiency reintroduces the self-assessment weakness the separate evaluator exists to remove, and picking the longest parallel draft optimizes a proxy nobody asked for.

    Source: Anthropic Engineering, "Building Effective Agents" — evaluator-optimizer where clear evaluation criteria exist and iterative refinement adds measurable valueReport a problem with this question

14. 14. An engineer routes every lookup through a subagent "for architectural cleanliness," including reading two configuration files whose paths are already known. Traces show each delegation re-establishes context, writes a report, and forces the coordinator to re-read that report — roughly tripling the tokens and wall time of the equivalent direct read. What is the right guidance?

    • A.Keep delegating but let subagents write directly into the coordinator's conversation history so the re-read disappears
    • B.Do small, well-specified reads in the main loop; delegate when exploration is broad or verbose and the subagent can return far less than it consumed✓ Answer
    • C.Keep delegating everything; a uniform architecture is worth the overhead and subagent context is isolated anyway
    • D.Keep delegating and reduce overhead by having subagents return their full raw tool output instead of a written report

    Every delegation carries fixed overhead — re-establishing context in an isolated subagent, producing a report, and the coordinator reading it back — so it only pays off when the subagent consumes far more material than it returns. A two-file read with known paths is strictly cheaper in the main loop. Subagents cannot write into the coordinator's history (context flows only through the prompt in and the report out), and returning raw output defeats the compression that justifies delegation in the first place.

    Source: Anthropic Claude certification (Architect – Foundations), Domain 1 — subagent delegation overhead and isolated subagent context; Anthropic Engineering, "Building Effective Agents"Report a problem with this question

15. 15. A coordinator delegates "check that the final deliverable meets the user's stated requirements" to a fresh verification subagent. In production it frequently returns "looks complete" for deliverables that in fact dropped a requirement. What is the most likely root cause?

    • A.Verification belongs in the main loop, which holds the original requirements; a fresh subagent starts with isolated context and knows only what its prompt hands it✓ Answer
    • B.Three verification subagents should run and the coordinator should accept the majority verdict
    • C.The verification subagent needs a stricter system prompt telling it to be skeptical and assume something is missing
    • D.The subagent will inherit the coordinator's conversation history automatically once its tool access is widened

    Subagents do not inherit the coordinator's conversation history or share memory between invocations; they see only what is explicitly passed in their prompt, and widening tool access does nothing to change that. A verifier that never received the full requirement list cannot detect an omission, so it defaults to judging surface plausibility. Verification therefore usually belongs in the main loop, which already holds the requirements — and if it must be delegated, the complete criteria have to be passed explicitly.

    Source: Anthropic Claude certification (Architect – Foundations), Domain 1 — subagents have isolated context and do not inherit coordinator history; verification in the main loopReport a problem with this question

16. 16. An automated migration agent executes roughly forty steps. Today a human reviews only the final diff, and any rejection forces the entire run to be redone from scratch. Where should human checkpoints go?

    • A.After every single step, so nothing can go wrong without a human noticing it immediately
    • B.Keep the single final review but add a self-review step where the agent critiques its own diff before presenting it
    • C.Remove the human review and rely on the test suite, since the tests already encode the same requirements
    • D.Where they change the outcome: approve the plan before execution begins, and gate the few steps that are expensive or irreversible✓ Answer

    Checkpoints are worth their friction only where human input can still redirect the work or prevent an unrecoverable action, which is why plan approval up front and gates before irreversible steps dominate a single terminal review. Reviewing after every step destroys the throughput that motivated automation and trains reviewers to rubber-stamp. Self-review is weak because the model retains the reasoning that produced the output, and tests cover only the requirements someone already thought to encode.

    Source: Anthropic Engineering, "Building Effective Agents" — human-in-the-loop checkpoints at plan approval and before costly or irreversible actions; Anthropic Claude certification (Architect – Foundations), Domain 1Report a problem with this question

17. 17. Traces of a stuck agent show it reissuing near-identical failing queries for fifteen turns, changing only the wording each time, until the iteration cap ends the run with no output. What is the most effective design change?

    • A.Raise the iteration cap so the agent has more chances to hit the right phrasing
    • B.Lower the iteration cap so unproductive runs end sooner and cost less
    • C.Detect non-convergence — repeated failing actions yielding no new information — and break out to a different strategy or a human handoff, carrying the partial results and what was attempted✓ Answer
    • D.Add a line to the system prompt instructing the agent not to repeat itself

    Designing for failure means the harness must recognize when a loop is not converging — the same action failing repeatedly while producing no new information — and change strategy rather than wait for a cap. Raising or lowering the cap only changes how much is spent before the same empty outcome, and a prompt instruction is probabilistic guidance over a behavior the harness can observe directly. Breaking out with partial results and a record of what was attempted also gives the next actor, human or agent, something to work from.

    Source: Anthropic Engineering, "Building Effective Agents" — designing for failure: detecting non-convergent loops and recovering; Anthropic Claude certification (Architect – Foundations), Domain 5 (structured error context with partial results)Report a problem with this question

18. 18. After an iteration cap of ten truncated several legitimate long-running tasks, an engineer removes the cap entirely and relies on the model to stop when it judges the work finished. How should the architect respond?

    • A.Replace the cap with a wall-clock timeout that silently discards whatever the run produced
    • B.Restore the cap and treat reaching it as successful completion so downstream steps still receive a result
    • C.Removing it is right; a well-prompted agent's own judgment is the appropriate stopping mechanism
    • D.Keep a cap as a backstop with defined behavior when it is hit — surface partial results and hand off — while normal termination stays driven by the loop's stop condition✓ Answer

    An iteration cap and a stop condition do different jobs: the stop signal ends normal runs, while the cap bounds the pathological ones and must never be the primary termination mechanism — nor be removed, since an unbounded loop can burn cost indefinitely. What matters is defining the behavior on exhaustion: emit partial results and escalate. Silently discarding output or labeling a truncated run as successful pushes an undetectable failure downstream.

    Source: Anthropic Engineering, "Building Effective Agents" — bounding iterations as a safety net rather than a termination mechanism; Anthropic Claude certification (Architect – Foundations), Domain 1 (arbitrary iteration caps are not a stop mechanism)Report a problem with this question

19. 19. An agent is being given a tool that permanently cancels a customer's subscription with no undo. Simulation shows it invokes the tool correctly in the large majority of cases. What should the architect require before this ships?

    • A.Gate the irreversible call behind an explicit confirmation step, and prefer a reversible variant such as scheduling cancellation at period end where the domain allows it✓ Answer
    • B.Allow the call and add an after-the-fact audit report that a team reviews weekly
    • C.A high correct-invocation rate in simulation is sufficient evidence to ship the tool ungated
    • D.Allow the call but require the agent to restate its intent in its response first, so the transcript records the decision

    For irreversible actions the relevant metric is not the average success rate but the cost of the residual failures, which by definition cannot be undone; a high majority still leaves a tail of unrecoverable harm. A confirmation gate enforced by the harness makes the bad outcome structurally impossible, and reshaping the action into a reversible form removes the hazard entirely. Narrating intent and weekly audits only document damage that has already occurred.

    Source: Anthropic Engineering, "Building Effective Agents" — irreversible actions warrant a confirmation gate; Anthropic Claude certification (Architect – Foundations), Domain 1 (human-in-the-loop for irreversible operations)Report a problem with this question

20. 20. A regulated onboarding process must run the same defined checks in the same order for every applicant, and auditors require evidence that no step was ever skipped. A team proposes an open-ended agent that decides the order of checks per applicant. What should the architect conclude?

    • A.Use a code-orchestrated workflow: predictability and auditability are the governing requirements, and autonomy trades away exactly those properties✓ Answer
    • B.Use the agent but log every decision it makes, which satisfies the auditability requirement
    • C.Use the agent with a system prompt that enumerates the mandatory checks and the order they must follow
    • D.Use the agent but add a final self-check turn in which it confirms that it skipped nothing

    Autonomy is a trade: it buys adaptability at the price of predictability, and a process whose entire requirement is that every applicant receives the identical sequence has nothing to gain and everything to lose. Logging records what happened but does not prevent a skipped check, and instructions in a system prompt are probabilistic guidance rather than a guarantee. An agent asked to confirm its own compliance is the weakest control of all, since it inherits the same reasoning that produced the omission.

    Source: Anthropic Engineering, "Building Effective Agents" — agents trade predictability for adaptability; Anthropic Claude certification (Architect – Foundations), Domain 1 (model-driven decisions versus deterministic workflows)Report a problem with this question

Practice questions based on the official Claude Certified Architect – Foundations (CCAR-F) exam guide and Anthropic's public documentation. This is an independent study tool, not affiliated with or endorsed by Anthropic, and does not grant certification. The real exam is 60 questions, 120 minutes, passing at a scaled 720/1000, delivered via Pearson VUE ($125). Official certification page →