20 Questions — Domain 1 : Solution Design & Architecture Quiz

Expand any question to reveal the correct answer and explanation.

1. 1 A solution architect is designing a system to process sensitive financial transactions that require a strict audit trail and deterministic execution steps. Which architectural pattern should be prioritized to meet these compliance requirements?

   Consider which pattern uses developer-defined sequences rather than model-driven step selection.

   Workflow Pattern

   Predetermined sequences and programmatic pipelines provide the predictability and auditability required for high-compliance environments.

   • ✗ Agentic Pattern

     While powerful, dynamic runtime loops are less deterministic and harder to audit compared to fixed programmatic pipelines.

   • ✗ Augmented LLM Pattern

     This pattern is typically limited to single-pass enrichment and lacks the structured multi-step sequencing needed for complex transaction processing.

   • ✗ Autonomous Swarm Pattern

     A swarm approach introduces excessive variability and coordination overhead that conflicts with the need for a deterministic audit trail.

2. 2 When implementing an agentic loop using the Claude Agent SDK, which field should the control flow logic inspect to determine if the loop should terminate?

   Look for a specific SDK-provided indicator that signals whether the model needs more information from a tool.

   stop_reason

   The loop must continue if the reason is 'tool_use' and terminate only when the model returns 'end_turn'.

   • ✗ finish_label

     This is not a standard SDK field for loop control; termination depends on specific model-emitted stop signals.

   • ✗ assistant_text

     Parsing natural language content for termination is considered an anti-pattern that can lead to unreliable execution or infinite loops.

   • ✗ iteration_count

     While useful as a safety cap, relying on a hardcoded count as the primary termination signal prevents the model from completing dynamic tasks.

3. 3 An architect discovers that a coordinator agent is unable to delegate tasks to specialized subagents during runtime. Which configuration setting is most likely missing?

   Focus on the technical mechanism required by the SDK to allow one agent to invoke another.

   Including 'Task' in the coordinator's allowedTools list

   The Task tool is the specific mechanism for spawning subagents, and it must be explicitly permitted in the agent definition.

   • ✗ Setting 'multiAgentEnabled' to true in the API payload

     Agent orchestration is managed through tool definitions rather than a single global boolean flag.

   • ✗ Configuring a shared memory buffer in the SDK options

     Subagents operate in isolated contexts and do not use shared memory; context must be passed explicitly in the prompt.

   • ✗ Adding 'SubagentSpawner' to the model's system prompt

     System prompts guide behavior, but the technical capability to spawn subagents is governed by the tools available to the coordinator.

4. 4 In a multi-agent research system, a synthesis subagent is failing to incorporate web search results obtained earlier by a different subagent. What is the most likely architectural cause?

   Recall the principle regarding how subagents access information from the coordinator's history.

   The coordinator failed to explicitly pass the search findings into the synthesis agent's prompt

   Subagents do not inherit the coordinator's conversation history or findings automatically due to context isolation.

   • ✗ The web search results exceeded the synthesis agent's default context window

     While window limits exist, the primary reason for a total lack of findings in subagents is a failure to pass the isolated context.

   • ✗ The search and synthesis agents are not sharing the same session ID

     Session IDs manage the lifecycle of a single thread, but subagent spawning creates isolated turns that require manual data injection.

   • ✗ The synthesis agent requires a 'PostToolUse' hook to read search outputs

     Hooks intercept results within a single agent's loop; they do not facilitate automatic data transfer between different agents.

5. 5 A developer wants to ensure that an agent never approves a refund exceeding $\$500$ without human intervention. Which implementation method provides the most reliable guarantee?

   Compare probabilistic methods like prompting with deterministic methods like programmatic gates.

   Using an SDK tool call interception hook to block the request

   Programmatic hooks provide deterministic enforcement of business rules that cannot be bypassed by model hallucinations.

   • ✗ Adding a strict boundary statement to the system prompt

     Prompt-based instructions are probabilistic and have a non-zero failure rate, making them insufficient for critical financial limits.

   • ✗ Increasing the model's temperature to improve rule adherence

     Higher temperature actually increases randomness and variability, which would likely decrease adherence to strict constraints.

   • ✗ Defining the refund amount in the JSON schema as a constant

     JSON schemas define structure but do not dynamically validate runtime values against business logic gates.

6. 6 To reduce total system latency when a coordinator needs to analyze 10 independent documents, which strategy should be implemented?

   Think about how to move from serial execution to simultaneous execution.

   Emit multiple Task tool calls in a single coordinator response

   Emitting multiple calls simultaneously spawns parallel subagents, reducing latency from the sum of all tasks to the duration of the longest one.

   • ✗ Utilize a sequential chain where each agent processes one document and hands off the state

     Sequential processing is inefficient for independent tasks and increases total latency unnecessarily.

   • ✗ Upgrade the coordinator to the highest capability tier (Opus class)

     A more capable model doesn't solve the underlying serial execution bottleneck; architectural parallelism is required.

   • ✗ Enable prompt caching for the document contents

     Caching reduces token costs but does not allow the model to process independent documents in parallel turns.

7. 7 When standardizing heterogeneous data formats (e.g., converting varied Unix and ISO timestamps) returned from multiple MCP tools, which SDK feature is most appropriate?

   Identify the point in the loop where tool outputs can be programmatically modified before the model sees them.

   PostToolUse hooks

   These hooks intercept tool results for transformation and normalization before the information is passed back to the model for reasoning.

   • ✗ System prompt formatting rules

     Instructions can ask the model to format its output, but they cannot normalize incoming raw data from external tools.

   • ✗ JSON Schema enums

     Enums restrict possible inputs but do not provide the computational logic needed to transform and normalize varied outputs.

   • ✗ .mcp.json environment variables

     Environment variables are used for server configuration and credentials, not for data transformation logic.

8. 8 A coordinator agent is designed to follow a strict 5-step checklist for every user request. Why might this 'procedural' approach be suboptimal compared to a 'goal-oriented' approach?

   Consider the difference between telling an agent 'how' to do a task versus 'what' the successful outcome looks like.

   It limits the subagents' ability to adapt when pre-specified paths fail

   Providing research goals and quality criteria allows agents to use their reasoning capabilities to navigate emerging patterns or failures.

   • ✗ It increases the token count of the coordinator's initial prompt

     While true, the primary architectural disadvantage is the loss of dynamic adaptability in autonomous systems.

   • ✗ It prevents the use of fork_session for divergent exploration

     Forking sessions is a separate technical capability that can be used regardless of prompt style, though rigid prompts make it less useful.

   • ✗ Procedural instructions automatically trigger iterative refinement loops

     Refinement loops must be explicitly designed; procedural prompts often ignore gaps that a goal-oriented synthesizer might catch.

9. 9 An agent with access to 25 different tools is frequently misrouting calls or failing to select any tool. Which architectural change is recommended to fix this 'capability bloat'?

   Think about the recommended maximum number of tools per agent to maintain high reliability.

   Decompose the agent into a coordinator and multiple specialized subagents

   Limiting tool sets to $4-5$ per specialized agent reduces decision complexity and significantly improves tool selection reliability.

   • ✗ Rewrite all tool descriptions to be at least 500 words long

     Excessively long descriptions can actually increase attention dilution and consume unnecessary tokens without solving the cognitive load issue.

   • ✗ Force 'tool_choice: any' to ensure a tool is always selected

     This forces the model to pick a tool, but it does not improve the accuracy of *which* tool is selected among 25 options.

   • ✗ Merge the 25 tools into a single monolithic API connector

     Monolithic tools hide parameter requirements and prevent the model from effectively inspecting and selecting specific capabilities.

10. 10 When passing context between subagents, why is it recommended to use a structured data format (like JSON) rather than a simple prose summary?

    Consider how an agent knows which piece of information came from which specific web page or document.

    To preserve attribution metadata such as source URLs and document names

    Structured formats allow metadata to remain cleanly separated from content, ensuring downstream agents can cite their sources correctly.

    • ✗ To reduce the overall token usage in the synthesis turn

      Structured formats often use more tokens than prose summaries, but they prioritize data integrity and provenance.

    • ✗ To avoid the 'lost-in-the-middle' effect in long prompts

      Format alone doesn't prevent this effect; careful placement of critical instructions at the beginning and end is still required.

    • ✗ Because subagents cannot parse natural language findings from the coordinator

      Subagents are capable of parsing prose, but doing so leads to the loss of granular details and strict metadata association.

11. 11 What is the specific architectural benefit of using 'context: fork' in an Agent Skill configuration?

    Think about the impact of intermediate 'noise' on the model's limited context window.

    It isolates the skill's outputs from polluting the main conversation history

    Isolated contexts allow for 'exploratory' turns that don't bloat the primary context window with intermediate discovery steps.

    • ✗ It allows the skill to inherit all tools from the parent coordinator

      Forking creates an isolated instance; tool inheritance must be explicitly defined in the 'allowed-tools' frontmatter.

    • ✗ It forces the model to use the Batch API for the skill execution

      The Batch API is an asynchronous processing mechanism unrelated to the real-time session isolation provided by 'fork'.

    • ✗ It automatically enables iterative refinement of the skill output

      Refinement is an orchestration pattern, whereas 'fork' is a session management technique for context control.

12. 12 In an orchestrator-worker pattern, what is the primary role of the 'synthesizer' component?

    Consider where the 'aggregation' of findings happens in a multi-agent system.

    To merge results from parallel workers and apply final quality control

    The synthesizer assembles the fragmented outputs of parallel agents into a coherent, verified final response.

    • ✗ To decompose the initial user query into independent tasks

      Decomposition is the primary responsibility of the planner or coordinator component at the beginning of the workflow.

    • ✗ To monitor subagent logs for policy violations

      Monitoring is typically handled via SDK hooks or external observability tools rather than a dedicated synthesis agent.

    • ✗ To provide worker agents with the tools they need to execute tasks

      Tool availability is defined in the agent's configuration (allowedTools) and is not provided dynamically by a synthesizer.

13. 13 A system architect is choosing between 'monolithic context' and 'progressive discovery' for a large document catalog. When should 'progressive discovery' be the preferred choice?

    Focus on the relationship between context window size and document volume.

    When the solution needs to scale across thousands of documents efficiently

    Loading everything at once causes context bloat and poor attention; querying on-demand is more cost-effective and accurate.

    • ✗ When latency is the absolute top priority regardless of cost

      Monolithic context can actually be faster for small sets since it avoids the round-trip delay of multiple tool calls.

    • ✗ When the documents are highly structured and never change

      If the data is small and stable, monolithic context is acceptable; progressive discovery is specifically for scaling and dynamic data.

    • ✗ When using a fast-tier model like Haiku for all tasks

      Model tier doesn't dictate context strategy, though Haiku's smaller window might make monolithic context impossible for large data.

14. 14 An architect is designing a multi-agent system where a coordinator routes communication between agents. What is a significant risk of 'overly narrow' task decomposition by the coordinator?

    Think about what happens to the 'big picture' when a problem is sliced into too many tiny, isolated pieces.

    Incomplete coverage of broad or ambiguous research topics

    If subtasks are too specific, agents may miss emerging connections or relevant information that falls outside their rigid assignments.

    • ✗ An exponential increase in token costs due to subagent spawning

      While costs increase, the primary architectural risk is a loss of research quality and comprehensive synthesis.

    • ✗ The coordinator being unable to manage parallel tool calls

      Decomposition granularity doesn't impact the coordinator's ability to handle parallel calls, which is an SDK-level capability.

    • ✗ Subagents automatically inheriting too much parent context

      The risk is actually the opposite; subagents inherit no context, and narrow prompts limit their ability to find relevant data.

15. 15 A multi-agent system is experiencing high latency because the coordinator waits for each subagent to finish before spawning the next, even when tasks are independent. What is the correct SDK-level fix?

    Consider the difference between a single tool call per turn and multiple tool calls per turn.

    Emitting multiple Task tool calls in a single coordinator response

    The SDK can execute these calls concurrently if they are emitted in a single turn, allowing parallel subagent processing.

    • ✗ Reducing the 'max_tokens' value for each subagent

      This limits output length but does not change the serial nature of the orchestration logic.

    • ✗ Increasing the number of MCP servers configured in .mcp.json

      Servers provide tools; they do not dictate how the coordinator chooses to sequence its calls to those tools.

    • ✗ Implementing a PostToolUse hook to trigger the next agent

      Hooks are for data transformation within a turn, not for managing multi-turn orchestration logic.

16. 16 When designing a recovery mechanism for an agent that crashed mid-task, what is the most effective approach?

    Think about how to provide the agent with a 'clean slate' while still acknowledging prior progress.

    Extract a structured checkpoint (manifest) and inject it into a new session's prompt

    Telling the agent exactly where to start with a summary of completed work is more reliable than resuming a bloated, broken session.

    • ✗ Use the --resume flag to reload the exact same conversation history

      Resuming a long history blindly often causes the model to repeat the same error that led to the crash.

    • ✗ Switch the model tier to Opus to handle the error state better

      A more capable model doesn't fix a state management failure; architectural recovery is required.

    • ✗ Increase the 'iteration_cap' in the agent's SDK settings

      Caps prevent infinite loops but do not help an agent recover lost state or context after a crash.

17. 17 What is the primary architectural drawback of using a single 'monolithic' prompt for a task requiring 10 different specialist tools?

    Consider how an model's performance changes as you 'stuff' more requirements into a single turn.

    It leads to attention dilution and increased tool selection errors

    As prompts get larger and tools more numerous, the model's ability to precisely follow complex instructions and select the right tool degrades.

    • ✗ It prevents the use of prompt caching for stable prefixes

      Monolithic prompts can still be cached, although any minor change to the large prompt will break the cache for subsequent calls.

    • ✗ It makes it impossible to use the Message Batches API

      The Batch API can handle large prompts; the issue is one of logic and reliability, not API compatibility.

    • ✗ It forces the model to use the 'augmented LLM' pattern

      A monolithic prompt can be used in any pattern, but it is specifically problematic for reliable tool use in complex systems.

18. 18 In the Model Context Protocol (MCP), what is the function of the 'isError' flag?

    Think about how the agent knows an 'Operation failed' message is a result rather than the actual intended output.

    To communicate tool failures back to the agent so it can decide how to recover

    Returning a structured error allows the agent to distinguish between valid data and failures, enabling retry or escalation logic.

    • ✗ To automatically terminate the agentic loop when a tool fails

      Termination is decided by the orchestrator or model; the flag simply provides the necessary information for that decision.

    • ✗ To notify the developer of a credential mismatch in .mcp.json

      Configuration errors are typically handled at the application or server log level, not within the runtime tool interaction flag.

    • ✗ To force the model to try a different tool automatically

      The model decides its next step based on the error message; it is not 'forced' into a specific action by the flag alone.

19. 19 An architect is designing an iterative refinement loop where a coordinator evaluates a synthesis subagent's output. What should the coordinator do if it detects a data gap?

    Think about the next logical step in a loop when a required component is missing.

    Re-delegate to search subagents with targeted queries for the missing info

    Iterative refinement involves identifying specific weaknesses and spawning new turns to improve the final synthesis.

    • ✗ Increase the synthesis agent's temperature to encourage more detail

      Higher temperature increases randomness but cannot magically generate missing data that the agent does not have.

    • ✗ Append the entire coordinator history to the synthesis agent's prompt

      This causes massive context bloat and doesn't solve the problem if the information was never retrieved in the first place.

    • ✗ Terminate the loop and return a 'Confidence Low' error to the user

      While possible, the goal of an architectural refinement loop is to proactively fill the gap before returning a response.

20. 20 Which scenario justifies the transition from a single-agent system to a multi-agent system?

    Look for a scenario where tasks can be done at the same time or must be kept strictly separate.

    When sub-tasks are truly independent or require distinct security permissions

    Parallelism and security isolation are the primary technical drivers for multi-agent complexity; otherwise, a single agent is more efficient.

    • ✗ When the total conversation history exceeds 2000 tokens

      Context length alone doesn't justify multiple agents; techniques like summarization or caching can manage a single agent's history.

    • ✗ When the task involves a 3-step linear data transformation pipeline

      Linear pipelines are handled better by a single agent with structured prompting to avoid handoff costs.

    • ✗ When the model used is from the Sonnet tier instead of Opus

      Model tier affects capability but doesn't dictate the architectural pattern, which should be based on task structure.