22 Agentic Architecture & Orchestration Practice Questions & Answers

1. 1. An agent loop ends the turn as soon as the assistant response contains any text block. Logs show runs stopping mid-task while that same response also carried tool_use blocks that were never executed. The context window is nowhere near full. What is the correct termination rule?

   • A.Execute tool calls until a preset iteration budget is exhausted, then treat the last text block produced as the final answer
   • B.Stop as soon as any tool result comes back as an error, because the model cannot make further progress after a failure
   • C.End the turn when the response's text reads as a conclusion, and continue looping when it reads as a narration of progress
   • D.Continue while stop_reason is tool_use, executing every tool_use block, and end the turn when stop_reason is end_turn✓ Answer

   The loop is driven by stop_reason, not by inspecting prose. A response may contain reasoning text and tool_use blocks together, so the presence of text says nothing about completion; stop_reason of tool_use means the model is still asking for work, and end_turn is the model's own signal that it has finished.

   Source: Anthropic Claude certification (Architect – Foundations), Domain 1, Task 1.1 — the agentic loop branches on stop_reason; Anthropic tool use documentationReport a problem with this question

2. 2. A hand-written agent loop sends only the newest tool_result back on each iteration instead of the accumulated turns. The agent re-issues lookups it already ran and contradicts its own earlier findings, though no single request comes close to the context limit. What is the fix?

   • A.Have the model carry forward the findings it still needs in its own text output, so each request needs only the latest result
   • B.Store past results in an external cache and instruct the model in the system prompt to consult that cache before repeating any lookup
   • C.Summarize every tool result into one sentence before returning it, so more iterations fit inside the same request budget
   • D.Append each assistant tool_use turn and its tool_result to the message list and resend the full history, since the API is stateless✓ Answer

   The Messages API is stateless, so the conversation exists only in what the caller resends. Each iteration must append the assistant turn containing tool_use and the user turn containing the matching tool_result, so the model reasons over everything it has already learned rather than over a single orphaned result.

   Source: Anthropic Claude certification (Architect – Foundations), Domain 1, Task 1.1 — tool results are appended to conversation history each iteration; Anthropic Messages API documentation (stateless requests)Report a problem with this question

3. 3. In a research system, subagents call one another directly to hand off intermediate findings. Each subagent works correctly in isolation, but every caller handles failures differently and no trace shows which agent supplied which input. What change fixes this?

   • A.Have each subagent write findings to a shared store that any other subagent may read, and log every write to that store
   • B.Keep the peer calls but require each subagent to attach its own agent name and a timestamp to every message it passes on
   • C.Merge the subagents into a single agent holding all the tools, so the handoffs happen inside one logged conversation
   • D.Route every inter-agent handoff through the coordinator, which logs each exchange and applies one error policy✓ Answer

   Hub-and-spoke orchestration exists precisely for this: when the coordinator mediates every exchange, there is one place that observes the flow, one error policy, and one point of control over what information each subagent receives. Direct peer calls scatter all three across the mesh.

   Source: Anthropic Claude certification (Architect – Foundations), Domain 1, Task 1.2 — the coordinator routes inter-subagent communication for observability and controlled information flowReport a problem with this question

4. 4. A coordinator delegates with the prompt "continue the migration using the constraints we established." The subagent invents its own constraints and its output contradicts the plan. Traces confirm the subagent completed its assigned task without error. What is the fix?

   • A.Have the coordinator check each returned output against the constraints and re-delegate whenever it spots a contradiction
   • B.State the constraints verbatim in the Task prompt, because a subagent starts with isolated context and gets only what it is given✓ Answer
   • C.Give the subagent the coordinator's full tool set so it can reopen the plan document and rediscover the constraints itself
   • D.Enable conversation inheritance for the subagent so the coordinator's earlier turns become visible during the delegated task

   Subagent invocations carry no automatic inheritance and no shared memory: a subagent sees its own prompt and nothing else. A phrase such as "the constraints we established" refers to a conversation the subagent never had, so the constraints have to be written into the delegation itself.

   Source: Anthropic Claude certification (Architect – Foundations), Domain 1, Task 1.3 — context must be passed explicitly in the subagent prompt; no automatic inheritance or shared memoryReport a problem with this question

5. 5. A coordinator is configured with allowedTools of Read, Grep and WebSearch, alongside four subagent definitions. At runtime it never delegates: it performs every subtask inline and the run exhausts its context budget. What explains this?

   • A.Read and Grep outrank delegation in the model's tool ordering, so the system prompt has to demote them for delegation to occur
   • B.Subagent definitions load only after the first delegation, so the coordinator has to be told to delegate once before they exist
   • C.Task is missing from allowedTools, so the coordinator has no tool with which to spawn a subagent and can only work inline✓ Answer
   • D.The subagent definitions carry no descriptions, so the coordinator cannot tell which one fits and quietly does the work itself

   Delegation happens through the Task tool, so Task must appear in the coordinator's allowedTools for any subagent to be spawned at all. With it absent the model has no delegation affordance to choose, and the only path left is doing the work in its own context.

   Source: Anthropic Claude certification (Architect – Foundations), Domain 1, Task 1.3 — the Task tool spawns subagents and allowedTools must include "Task" for delegationReport a problem with this question

6. 6. A support coordinator invokes all six of its subagents on every ticket. For a simple password-reset request that means five delegations returning nothing usable, roughly tripling cost and latency. Each subagent handles its own ticket type correctly. What should change?

   • A.Merge the six subagents into two broader ones, so each ticket triggers fewer delegations whatever it happens to contain
   • B.Instruct each subagent to return immediately with an empty result when the ticket falls outside its own specialisation
   • C.Keep the fixed pipeline but run all six delegations concurrently, so the wasted work stops adding to end-to-end latency
   • D.Have the coordinator read the ticket first and invoke only the subagents whose specialisation that ticket actually needs✓ Answer

   Selecting which subagents to invoke is part of the coordinator's job, alongside decomposition, delegation and aggregation. A coordinator that always runs the full roster is a fixed pipeline wearing a coordinator's name, and it pays for capabilities the request never needed.

   Source: Anthropic Claude certification (Architect – Foundations), Domain 1, Task 1.2 — the coordinator dynamically selects which subagents to invoke rather than always running the full pipelineReport a problem with this question

7. 7. A summarization subagent is defined with the coordinator's full tool set. In one run it edited two of the source files while summarizing them, and the edit reached a commit. Its summaries themselves are accurate. What is the most maintainable fix?

   • A.Run the subagent against a throwaway copy of the repository and discard that copy once the summary has been returned
   • B.Have the coordinator strip file-modifying tool calls out of the subagent's transcript before the results are aggregated
   • C.Restrict the tools in that subagent's definition to the read-only set its role needs, so writing is simply unavailable✓ Answer
   • D.Add a line to the subagent's system prompt forbidding edits, and have the coordinator inspect the diff after each run

   An AgentDefinition carries a description, a system prompt and tool restrictions, and the restrictions are the deterministic control. Removing write tools makes the unwanted action impossible, whereas a prompt telling the model not to write leaves a non-zero failure rate on every run.

   Source: Anthropic Claude certification (Architect – Foundations), Domain 1, Task 1.3 — AgentDefinition carries tool restrictions; Task 1.4 — programmatic enforcement over prompt-based guidanceReport a problem with this question

8. 8. Three order-lookup tools return timestamps as Unix seconds, as ISO 8601 strings, and as a vendor status code. The agent mixes them up when comparing shipment dates. Each tool is owned by a different team and cannot be modified. What is the best fix?

   • A.Describe all three formats in the system prompt and instruct the model to convert them before it compares any dates
   • B.Add a PostToolUse hook that rewrites each tool's result into one common shape before the model ever sees it✓ Answer
   • C.Expose the three lookups behind one tool whose description explains which format each underlying service returns
   • D.Give the agent a conversion tool and require it to call that tool on every timestamp it receives from a lookup

   A PostToolUse hook intercepts tool results on their way back and can normalise heterogeneous formats deterministically, so the model reasons over one representation. The prompt-based and extra-tool options both depend on the model choosing to convert correctly every single time.

   Source: Anthropic Claude certification (Architect – Foundations), Domain 1, Task 1.5 — PostToolUse hooks intercept tool results to normalize heterogeneous formats before the model sees themReport a problem with this question

9. 9. An agent escalates to a human queue with the note "customer is unhappy about a refund, please assist." The humans on that queue cannot see the conversation transcript, so they re-ask the customer everything. What should the handoff summary carry?

   • A.A sentiment score, the number of turns taken, and the agent's stated confidence in its own reading of the problem
   • B.The policy sections consulted and the tool calls attempted, so the human can repeat those steps and confirm them
   • C.The customer identifier, the root cause established, the refund amount in dispute, and the action the agent recommends✓ Answer
   • D.The full verbatim transcript of the exchange, so the human can read what happened and judge the case unaided

   A structured handoff exists so the receiving human can act without reconstructing the case, which means the identifying key, the diagnosis, the disputed figure and a recommended next action. A raw transcript shifts the reconstruction work onto the human, and sentiment or self-reported confidence tells them nothing actionable.

   Source: Anthropic Claude certification (Architect – Foundations), Domain 1, Task 1.4 — structured handoff summaries for escalation must carry customer ID, root cause, amount and recommended actionReport a problem with this question

10. 10. A coordinator prompt lists twelve numbered steps that every subagent must perform. When a source turns out to be unavailable, subagents follow the numbering anyway and return empty sections instead of adapting. Which prompt design is better?

    • A.Keep the twelve steps and attach to each one a branch describing what to do when its source is unavailable
    • B.Move the twelve steps into each subagent's own definition so the coordinator prompt carries only the topic
    • C.Cut the list to the three steps that matter most and let the model infer the other nine from the task description
    • D.State the goal and the quality criteria the result must meet, leaving each subagent to choose how it gets there✓ Answer

    Coordinator prompts should specify what a good result looks like rather than the procedure for producing it, because subagents can then adapt when reality departs from the plan. Enumerated procedures convert an adaptive agent into a brittle script that keeps marching past a dead source.

    Source: Anthropic Claude certification (Architect – Foundations), Domain 1, Task 1.3 — coordinator prompts state goals and quality criteria rather than step-by-step proceduresReport a problem with this question

11. 11. A research coordinator synthesizes subagent results into a final report in a single pass. Reviewers keep finding whole questions from the brief that no subagent addressed. Every subagent returned successfully. What should the coordinator do?

    • A.Ask each subagent to keep widening its own search until it is satisfied it has covered the brief as it sees it
    • B.Evaluate the synthesis against the brief, name the uncovered questions, and re-delegate targeted queries for those gaps✓ Answer
    • C.Produce the synthesis twice and keep whichever report covers more of the brief's questions side by side
    • D.Raise the number of subagents so more of the brief is covered on the first pass and gaps become unlikely

    Iterative refinement puts the coverage check where the whole picture exists: the coordinator compares the synthesis against the original brief and re-delegates narrow follow-up queries for what is missing. No individual subagent can detect a gap, because each one sees only its own assignment.

    Source: Anthropic Claude certification (Architect – Foundations), Domain 1, Task 1.2 — the coordinator evaluates synthesis for gaps and re-delegates targeted queriesReport a problem with this question

12. 12. A brief asks for a survey of creative industries. The coordinator's log shows it split the work into painting, sculpture and illustration. Each subagent returned thorough, accurate, well-sourced results. The finished report never mentions film, music or games. Where is the defect?

    • A.In the synthesis step, which merged three overlapping result sets without noticing how much of the domain was absent
    • B.In the coordinator's decomposition, which mapped a broad domain onto one narrow slice of it before any subagent ran✓ Answer
    • C.In the subagents, which searched only within the terms handed to them instead of widening to neighbouring industries
    • D.In the brief, which used a term too broad to decompose and should have enumerated the industries it wanted covered

    The stem rules out the downstream stages by stating that every subagent returned thorough and accurate work: they executed their assignments correctly, and the assignments themselves were wrong. Scoping the domain is the coordinator's responsibility, and a decomposition that omits most of a domain cannot be rescued later.

    Source: Anthropic Claude certification (Architect – Foundations), Domain 1, Task 1.2 — the coordinator owns decomposition; overly narrow decomposition is a coordinator defect, not a subagent failureReport a problem with this question

13. 13. Four subagents researching one market each returned roughly the same eight sources. Cost is four times the useful yield and the synthesis is dominated by duplicates. Each subagent's individual output is high quality. What is the fix?

    • A.Reduce the team to one subagent, since four of them evidently produce no more coverage of the market than one does
    • B.Assign each subagent a disjoint slice of the question so their searches cover different ground, not the same ground✓ Answer
    • C.Give each subagent a different search tool so that the underlying indexes differ and the returned sources diverge
    • D.Deduplicate the overlapping sources during synthesis and keep the copy returned by whichever subagent found it first

    Parallel subagents pay off only when their scopes are partitioned, because four agents pointed at the same question will converge on the same top results. Deduplicating afterwards removes the clutter but not the wasted spend, and a different index is no guarantee of different coverage.

    Source: Anthropic Claude certification (Architect – Foundations), Domain 1, Task 1.2 — partition scope across subagents to minimize duplicationReport a problem with this question

14. 14. A long session's tool results describe a database schema that has since been rewritten, and the agent keeps citing columns that no longer exist. A teammate proposes fork_session to branch away from the stale results. What should the architect do?

    • A.Resume the session and instruct the agent to disregard every schema fact it read before the rewrite took place
    • B.Start a new session seeded with a structured summary of what still holds, since context is append-only and stale entries stay✓ Answer
    • C.Run a compaction pass so the outdated schema results are compressed away and what remains in context is accurate
    • D.Fork the session as proposed, since a fork starts from a copy that leaves behind the tool results the branch no longer needs

    Context is append-only: nothing already in the history can be edited or deleted, and a fork copies the history it branches from rather than pruning it. Compaction shortens history but does not correct it. The reliable route is a fresh session carrying an injected checkpoint of the conclusions that are still true.

    Source: Anthropic Claude certification (Architect – Foundations), Domain 1, Task 1.7 — fork_session is for divergent branches from a shared baseline, not for clearing stale tool resultsReport a problem with this question

15. 15. A team has spent an hour having an agent analyse a service, and now wants two competing refactor plans that both build on that analysis without either one polluting the other. Which session mechanism fits?

    • A.Stay in one session and ask for both plans in a single request, so the model can contrast them as it writes them
    • B.Resume the session for the first plan, then resume it a second time for the other once the first has been written out
    • C.Start two new sessions and re-run the analysis in each, so both plans rest on evidence gathered freshly for them
    • D.Fork the session twice from the finished analysis, giving each branch the same baseline and an independent history✓ Answer

    fork_session creates independent branches from a shared baseline, which is exactly the shape of this problem: the expensive analysis is reused once, and each plan then develops in a history the other cannot see. Resuming twice lets the first plan bias the second, and re-analysing pays the same cost again.

    Source: Anthropic Claude certification (Architect – Foundations), Domain 1, Task 1.7 — fork_session creates independent branches from a shared analysis baselineReport a problem with this question

16. 16. A review agent given thirty changed files in one request returns contradictory findings and misses issues in the middle of the set. The requirement is per-file correctness plus consistency of one shared interface across the files. What decomposition is right?

    • A.One pass per file, each told what the previous file contained, so the interface is tracked as the sequence advances
    • B.One pass per file for local issues, then a further pass over the collected findings for cross-file consistency✓ Answer
    • C.Three passes over all thirty files, keeping only the findings that appear in at least two of the three runs
    • D.One pass over all thirty files with the shared interface described first, so the model anchors on it as it reads

    The work has two predictable aspects, so it decomposes into a fixed chain: local analysis file by file, then one integration pass over the aggregated findings. Restating the interface up front does not fix attention dilution across thirty files, and majority voting suppresses real defects that only one run happened to catch.

    Source: Anthropic Claude certification (Architect – Foundations), Domain 1, Task 1.6 — fixed sequential decomposition: per-file analysis followed by a cross-file integration passReport a problem with this question

17. 17. An architect is asked to find where a codebase would break under ten times its current traffic. Which subtasks matter cannot be known until the structure has been mapped, and each finding changes what is worth looking at next. How should the work be organized?

    • A.As an adaptive plan: map the structure first, then let each finding decide which area gets investigated next✓ Answer
    • B.As an adaptive plan drawn up in full before any code is read, then executed without revision so the run stays auditable
    • C.As a fixed chain: profile the service, then review the queries, then review the caching, then write the findings up
    • D.As a fixed chain run once per service, applying an identical checklist to each service in the system in turn

    Dynamic decomposition belongs to open-ended investigation, where the useful subtasks emerge from what earlier steps uncover. A fixed chain suits work whose aspects are known in advance, and a plan that is fixed the moment it is written is a fixed chain no matter what it is called.

    Source: Anthropic Claude certification (Architect – Foundations), Domain 1, Task 1.6 — dynamic adaptive decomposition for open-ended investigation versus fixed prompt chainingReport a problem with this question

18. 18. A team is choosing between two offerings for a new agent, both marketed as managed, and cannot articulate what actually differs. Which axis separates them?

    • A.Whether billing is per token consumed or per agent run, which determines the cost model once volume grows
    • B.Whether conversation history is retained by the vendor or has to be resent by the caller on every request
    • C.Whether the model can be swapped for another provider's model without rewriting the agent's tool definitions
    • D.Whether the vendor supplies only the harness, meaning the loop and context management, or also hosts the infrastructure✓ Answer

    Two things get called managed for different reasons. A harness supplies the agent loop and context management while the team still runs the process; a managed deployment also owns the infrastructure the agent executes on. Naming which of the two a product provides is what makes the comparison meaningful.

    Source: Anthropic Claude certification (Architect – Foundations), Domain 1 — agent harness (loop and context management) versus deployment infrastructure as separate build decisionsReport a problem with this question

19. 19. A team wants an approval gate before any write tool executes, plus a log of every tool result, and is debating whether to write the agent loop themselves or let a runner drive it. What is true about the control they retain?

    • A.Neither allows interception once tools are registered; approval has to be enforced inside each tool's implementation
    • B.Either way they can act on each turn: gating a tool call, logging results, or altering a result before it returns✓ Answer
    • C.Only a hand-written loop allows interception; a runner exposes the final output and nothing about the turns beneath it
    • D.Only a runner allows interception, because gating requires the vendor's process to observe the calls as they are made

    The choice between owning the loop and letting a runner drive it changes how much plumbing the team writes, not whether per-turn control exists. Both shapes expose the points where a tool call can be approved or denied, a result can be logged, and a result can be edited before it goes back to the model.

    Source: Anthropic Claude certification (Architect – Foundations), Domain 1 — owning the agent loop versus a runner-driven loop; per-turn hooks for approval, logging and result modification exist in bothReport a problem with this question

20. 20. A service creates a new server-side agent object on every incoming request before starting a run, passing the same model and tool list each time. Two runs have already gone out with a mismatched tool list after a partial deploy. What is the right pattern?

    • A.Create the agent once with its model and tools, then reference it by id on each run and pass only that run's input✓ Answer
    • B.Create one agent per customer so its tool list can be tailored, and version each object whenever the tools change
    • C.Move the model and tool list onto each run's own parameters, so a run is self-describing and cannot drift from others
    • D.Keep creating an agent per request but read the model and tool list from one shared configuration file at start-up

    A server-managed agent is created once and referenced by id thereafter, which is why its model and tool configuration belongs on the persisted agent rather than on each run. Re-declaring that configuration per request reintroduces exactly the drift the persisted object was meant to eliminate.

    Source: Anthropic Claude certification (Architect – Foundations), Domain 1 — server-managed agents follow a create-once, reference-by-id lifecycle with configuration held on the agentReport a problem with this question

21. 21. A main agent producing a design proposal spends most of its context reading twelve API reference pages, and by the end it cites generic patterns rather than the specifics it read earlier. What structural change helps most?

    • A.Split the proposal across twelve subagents, one per API, and concatenate the sections each of them returns
    • B.Read the twelve pages in the main loop but have the model summarize each one immediately after it finishes reading it
    • C.Delegate each reading task to a subagent that returns a short summary, keeping the main context on the proposal itself✓ Answer
    • D.Place the twelve pages in the system prompt so they sit at the front of the context and are never displaced by later turns

    Fanning out to subagents isolates reading-heavy subtasks, so the bulk of the reference material never enters the main loop's context and only the distilled findings do. Summarizing in place still pays the full reading cost in context, and splitting the proposal itself fragments the one thing that needs a single coherent author.

    Source: Anthropic Claude certification (Architect – Foundations), Domain 1 — fan out reading-heavy subtasks to subagents so the main context is not filled with material the main loop does not needReport a problem with this question

22. 22. A nightly agent reconciles invoices and must continue where it stopped if a run is interrupted. Each run starts a fresh process under a scheduler and nothing from the previous run is in memory. How should progress be handled?

    • A.Keep one long-lived session open across nights and resume it, letting the conversation history carry the progress
    • B.Have the scheduler retry a failed run immediately, so an interruption is recovered before the next night comes around
    • C.Have each run start over from the beginning, since reprocessing invoices is idempotent and avoids storing any state
    • D.Write a structured checkpoint of completed work to durable storage and load it into the prompt at the start of each run✓ Answer

    A scheduled agent has no process that survives between runs, so its state has to live outside the process and be injected back into the prompt when the next run starts. Relying on a session to persist assumes continuity the scheduler does not provide, and restarting from zero grows unbounded as the backlog grows.

    Source: Anthropic Claude certification (Architect – Foundations), Domain 1, Task 1.7 — long-running and scheduled agents externalize state as structured checkpoints loaded on resumeReport 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. It is delivered via Pearson VUE; Anthropic publishes the current question count, time limit, passing score and fee in the official CCAR-F exam guide. Official certification page →