Courseiva

CCNA Agentic Architecture and Orchestration Questions

61 questions · Agentic Architecture and Orchestration · All types, answers revealed

1
MCQmedium

An architect is building an agent that uses a 'Plan-and-Execute' pattern. The agent first generates a multi-step plan, then executes each step. During execution, the agent discovers that Step 2 is impossible due to a missing API key. How should the agent be designed to handle this?

A.The agent should skip the failing step and proceed to Step 3 automatically
B.The agent should return to the planning phase to modify the remaining steps
C.The system should hard-crash to ensure the developer is notified of the issue
D.The agent should retry Step 2 indefinitely until the API key is provided
AnswerB

This is the 'Re-planner' pattern. When a failure occurs, the agent should take the error information and feed it back into the planning model. This allows the model to generate an alternative strategy that achieves the goal without the missing API key, or to inform the user about the specific requirement needed.

Why this answer

Dynamic re-planning is a key feature of advanced agentic systems. When an agent encounters an obstacle that prevents the execution of a pre-defined plan, it must be able to recognize the failure, update its internal state, and generate a new plan that either bypasses the problem or addresses the root cause, rather than continuing to attempt a doomed plan.

Exam trap

Candidates often assume the agent should just retry the failed step or throw an error, failing to realize the agent must re-plan based on the new environmental constraint.

2
Multi-Selectmedium

An architect is optimizing a multi-agent system for a legal firm. The system uses a 'Router' agent followed by several 'Specialist' agents. Which THREE techniques will most effectively minimize latency in this specific architecture?

Select 3 answers
A.Implement prompt caching for the specialist agents' long system prompts
B.Use Claude 3.5 Haiku for the initial routing decision
C.Execute multiple specialist agents in parallel when their tasks are independent
D.Set 'max_tokens' to 1 for the specialist agents' responses
E.Force the model to use the 'computer_20241022' beta tool for all lookups
AnswersA, B, C

Specialist agents often require extensive context and detailed instructions that remain static across many requests. By using prompt caching, the architect ensures that these large prompts are not re-processed for every turn, drastically reducing the latency and cost of the specialist phase in a multi-agent conversation.

Why this answer

Latency is a primary concern in multi-agent systems due to the sequential nature of LLM calls. Prompt caching significantly reduces time-to-first-token for large system instructions, while selecting faster models like Claude 3.5 Haiku for routing tasks and executing independent specialist tasks in parallel ensures the overall workflow remains responsive and efficient for the end-user.

Exam trap

Candidates often focus on model intelligence for all steps, ignoring that routing should be fast and that prompt caching is essential for minimizing latency in multi-agent systems.

3
MCQmedium

A document-triage agent uses Claude with a read_attachment tool. During testing, the agent calls read_attachment for a PDF, receives a tool_result containing the extracted text, and then immediately calls read_attachment again for the same file id, repeating several times until the orchestrator stops it. The tool itself works correctly and returns valid content each time. What is the most effective architectural fix?

A.Raise the tool's timeout so the repeated calls have more time to complete and the agent stops retrying prematurely.
B.Have the orchestrator detect repeated identical tool_use requests against the same arguments and short-circuit them by returning a cached tool_result or by injecting a message that the content was already provided.
C.Remove read_attachment from the tools list and paste the document text directly into the system prompt for every request.
D.Increase the agent's iteration budget so it has more chances to break out of the repetition on its own.
AnswerB

Idempotent tools plus orchestrator-level duplicate detection break the loop without changing what the model can accomplish. Returning the cached result or explicitly noting the content is already available gives Claude the information it needs to proceed, and the guard prevents unbounded repetition regardless of why the model re-requests. This keeps control in deterministic host code.

Why this answer

Repeated identical tool calls with valid results indicate the agent is not recognizing that its need is already satisfied, so the robust fix is deterministic duplicate detection in the orchestrator, paired with cached results or an explicit signal that the content was already supplied. Timeouts, larger budgets, and inlining documents all leave the loop mechanism intact or trade away needed flexibility.

Exam trap

The trap here is treating repeated successful tool calls as a tool reliability problem, when the tool is working and the loop actually originates in the agent's control flow and context handling.

4
MCQhard

An architect is designing a research agent whose context window is filling with raw web page HTML. The agent must keep working across dozens of sources without exceeding the context limit. Which architecture best preserves reasoning quality over a long session?

A.Store full page text in the conversation and rely on the model's long-context ability to attend to everything.
B.Increase the `max_tokens` output parameter so Claude can compress the HTML itself in one pass.
C.Run a sub-agent that reads each page and returns a structured summary, and keep only those summaries in the main agent's context.
D.Set the model's temperature to zero so responses become shorter and consume fewer tokens.
AnswerC

Delegating page reading to a sub-agent with its own context window keeps the main thread lean. The sub-agent absorbs the raw HTML, extracts structured findings, and returns a compact result. The orchestrator retains only distilled knowledge, preserving attention on high-value tokens and enabling the session to span far more sources than a flat transcript would allow.

Why this answer

Context management in agentic systems is an architectural concern, not a parameter tweak. Sub-agents act as context firewalls: they consume noisy inputs in their own window and return only distilled results to the orchestrator. This keeps the primary reasoning thread focused on high-signal tokens and enables the session to scale across many sources without truncation or attention dilution.

Exam trap

The trap here is treating context limits as a tuning problem solved by temperature or max_tokens, rather than as an architecture problem solved by sub-agents and summarization.

5
MCQhard

An architect is building a Claude-based agent that must reconcile invoice disputes. The orchestrator runs a single loop where Claude may emit several tool_use blocks in one assistant turn: one block calls lookup_invoice, another calls fetch_payment_history, and a third calls get_contract_terms. A junior developer proposes executing the first tool_use block, feeding its tool_result back to Claude, and only then deciding whether to run the other two. What is the architecturally correct way for the orchestrator to handle this turn?

A.Execute all tool_use blocks from the assistant turn, then return every tool_result in a single subsequent user message keyed by tool_use_id.
B.Execute the first tool_use block, return its result alone, and let Claude re-issue the remaining two calls in a fresh assistant turn.
C.Execute the three calls sequentially, returning each tool_result in its own separate user message as soon as that call finishes.
D.Skip execution of the tool_use blocks and send a natural-language summary of the assistant text so Claude can decide what to do next.
AnswerA

Claude's tool-use contract expects the orchestrator to satisfy every tool_use block it emitted in that assistant turn and to return the results together in the following user message, each result carrying the matching tool_use_id. Because the three calls are independent lookups, running them in parallel and replying once preserves the turn pairing and avoids leaving an unresolved tool_use block, which the API rejects.

Why this answer

An assistant turn containing multiple tool_use blocks constitutes a single batched request for those tools. The orchestrator must execute each block and return all tool_result entries together in one subsequent user message, each tagged with the matching tool_use_id. This keeps the conversation structurally valid, lets independent lookups run concurrently, and minimizes model round-trips before Claude can reason over the combined evidence.

Exam trap

The trap here is assuming tool calls must be handled one at a time, when a single assistant turn can legitimately request several tools that must all be answered together.

6
MCQeasy

A support agent running on the Claude Messages API must look up a customer's order status before answering. The developer writes a single request that includes the get_order_status tool definition and the user's question, then expects the model to return the order status directly in its first response. What actually happens, and what must the developer implement?

A.Claude returns a tool_use block requesting get_order_status; the application must execute the tool and send back a tool_result, then call the API again to get the final answer.
B.Claude returns the order status immediately because tool definitions are executed server-side by Anthropic before the response is generated.
C.Claude executes the tool and returns both the tool output and its final answer in one response, so no second request is needed.
D.The request fails with a validation error because a tool definition cannot be supplied alongside a normal user text message.
AnswerA

The API is stateless and does not execute tools on the caller's behalf. When Claude decides a tool is needed, it returns stop_reason tool_use with a tool_use block containing the name and arguments; the application runs the function, appends a user turn with the matching tool_result, and issues another request so Claude can compose the answer.

Why this answer

Tool use in the Claude Messages API is a caller-driven loop: the model emits a tool_use request, the application executes the function and returns a tool_result, and a follow-up request lets Claude produce the final answer. Because the API is stateless and never runs customer functions itself, the developer must implement this round trip.

Exam trap

The trap here is assuming the model itself executes declared tools, when tool definitions only describe callable functions and every execution plus result round trip is the application's responsibility.

7
MCQmedium

An architect is designing a system where Claude must handle complex multi-step customer inquiries. The current implementation uses a single prompt, but it often fails on high-reasoning tasks. Which agentic pattern should be implemented to allow a primary model to decompose the user's request into sub-tasks for specialized worker agents?

A.The Router Pattern
B.The Orchestrator-Workers Pattern
C.The Parallelism Pattern
D.The Evaluator-Optimizer Pattern
AnswerB

This pattern allows a primary agent to analyze a complex request and dynamically generate a plan consisting of multiple sub-tasks. Each worker agent handles a specific portion of the plan, and the orchestrator synthesizes their outputs into a final response, making it ideal for high-reasoning tasks requiring structural decomposition.

Why this answer

The Orchestrator-Workers pattern is essential for high-complexity tasks that require decomposition. By using a central orchestrator to plan and delegate sub-tasks to specialized workers, the system avoids context dilution and prevents the model from being overwhelmed by too many instructions at once. This pattern enhances reliability and allows for more granular error handling and parallel execution of independent sub-tasks in a production environment.

Exam trap

Candidates often try to force a single model to handle too many responsibilities, leading to context bloat and poor performance, rather than delegating tasks via the Orchestrator-Workers pattern.

8
MCQmedium

Refer to the exhibit. An architect is reviewing the tool-use integration for a custom Claude agent. What is the primary purpose of setting the 'is_error' field to true in this specific API payload?

A.To trigger an automatic retry of the tool call by the Anthropic API
B.To inform Claude that the tool call was unsuccessful so it can adjust its next action
C.To immediately terminate the conversation and return a 400 status code to the user
D.To ensure that the specific tool call is not billed to the customer account
AnswerB

Setting 'is_error' to true provides a clear signal to Claude that the attempted tool execution failed. This allows the model to use its reasoning capabilities to interpret the error message in the content field and formulate a new plan, such as trying a different tool or correcting the input parameters.

Why this answer

The 'is_error' field is a specific signal in the Anthropic API that informs Claude that the tool execution failed. This signal is distinct from the content of the message, allowing the model's internal reasoning to distinguish between a successful tool output that happens to contain 'error text' and a genuine failure of the tool execution environment, prompting a retry or alternative logic.

Exam trap

Candidates often mistake 'is_error' for a simple logging flag, failing to realize it is a specific API signal that forces the model to re-evaluate its strategy rather than just reading output.

9
MCQmedium

You are building a customer-support agent with the Anthropic Messages API. The agent must call a `get_order_status` tool, and the result is required before it can decide whether to issue a refund. The tool sometimes takes several seconds to respond. Which approach best ensures the agent does not prematurely finalize its answer before the tool result is available?

A.Use `stop_sequences` to halt generation whenever the model emits a `tool_use` block.
B.Set `tool_choice` to `{"type": "any"}` so the model is forced to call a tool on every turn.
C.Increase `max_tokens` so the model has room to wait for the tool response within the same completion.
D.After receiving a `tool_use` block, execute the tool and send a `user` message containing a `tool_result` block with the matching `tool_use_id` before requesting the next completion.
AnswerD

The Messages API tool-use loop requires the application to return a `tool_result` block whose `tool_use_id` matches the model's `tool_use` block. Only then does the model have the data needed to reason about the refund. Sending the result in a `user` turn preserves the conversation structure and lets the agent continue deterministically.

Why this answer

Tool use in the Anthropic Messages API is a multi-turn exchange: the model emits a `tool_use` block, the application executes the function, and the application returns a `tool_result` block tied to the same `tool_use_id`. The model cannot finalize a refund decision until that result is in context, so completing the round trip before the next completion is what prevents premature answers.

Exam trap

The trap here is assuming the model can pause mid-completion to wait for a slow tool, when in reality the application must complete the tool round trip and send a `tool_result` before the next request.

10
Multi-Selecthard

An architect is evaluating the use of 'Prompt Caching' within a complex Orchestrator-Workers agentic loop. Which TWO benefits are most significant for this specific use case?

Select 2 answers
A.Reduced cost for processing the large system prompt in every worker call
B.Improved reasoning capabilities of the worker models on complex tasks
C.Decreased time-to-first-token for iterative turns in the agent loop
D.Automatic correction of errors in the model's tool-use JSON output
E.Elimination of the need for an external database to store agent state
AnswersA, C

In an orchestrator-workers pattern, each call to a worker often includes the same set of complex instructions and tool schemas. Prompt caching allows the developer to pay a reduced rate for these tokens after the first turn, leading to significant cost savings in workflows that involve many sub-agent interactions.

Why this answer

Prompt caching is particularly effective in agentic workflows where large system prompts and tool definitions are repeated across multiple turns. By caching these static elements, the architect can significantly reduce the latency of each turn and lower the cost of the overall conversation, as the model doesn't need to re-process the foundational instructions every time.

Exam trap

Candidates often overlook how prompt caching specifically benefits iterative loops, mistakenly thinking it only helps with initial request costs rather than reducing latency across turns.

11
MCQmedium

An organization is deploying an agentic system that must maintain long-running conversations over several days, involving hundreds of tool calls. What is the most critical architectural consideration for managing the 'messages' array to prevent exceeding Claude's context window?

A.Clear the message history every time a tool returns a successful result
B.Implement a context management strategy like summarization or message pruning
C.Always use the 'system' role to store the entire history of tool outputs
D.Switch to a smaller model version when the context window reaches 50% capacity
AnswerB

To handle long-running agents, architects must actively manage the message history. This involves summarizing earlier parts of the conversation into a concise 'memory' block and pruning old tool-use blocks that are no longer needed for the current reasoning step, ensuring the model stays within its token limits while retaining key info.

Why this answer

Long-running agentic conversations can quickly exceed the context window of even large models like Claude 3.5 Sonnet. Architects must implement context management strategies, such as summarizing old turns or using a sliding window approach, to keep the most relevant information within the prompt while removing or distilling older, less relevant interactions to maintain performance.

Exam trap

Candidates often assume models have infinite memory or that simply increasing context windows is the solution, failing to implement active management like pruning or summarization for long-running sessions.

12
MCQmedium

An agentic architecture uses Claude to resolve customer support tickets by invoking database lookup and refund tools. During execution, the model frequently makes redundant API calls for the same user ID within a single turn. Which orchestration pattern best resolves this issue while maintaining deterministic behavior?

A.Increase the model temperature to encourage more diverse reasoning paths and avoid repetitive loops.
B.Implement an aggressive timeout policy that terminates the agent session immediately upon detecting duplicate tool calls.
C.Cache read-only tool responses locally for the duration of the conversation turn to short-circuit identical invocations.
D.Remove the tool definition from the system prompt dynamically once the agent attempts a second invocation.
AnswerC

Caching read-only tool outputs within the session context successfully eliminates redundant API calls without altering core model logic. This practice ensures high throughput, minimizes database load, and preserves predictable execution states across multi-turn agent interactions.

Why this answer

Implementing a caching mechanism for read-only tool outputs directly prevents redundant executions within the agent loop. Caching preserves state consistency, reduces latency, and protects downstream services from rate limits. This approach is critical in production agentic architectures where unnecessary tool calls degrade user experience and inflate operational costs.

Exam trap

Candidates often suggest re-prompting the model to be 'more careful,' which is non-deterministic and unreliable, instead of implementing architectural caching to solve the root cause of redundant calls.

13
MCQeasy

Where should the general 'rules of engagement' for an agent (such as tone, persona, and high-level safety constraints) be placed in an Anthropic API call?

A.Inside the 'input' parameters of every tool definition
B.Within the 'system' parameter of the Messages API request
C.As a 'user' role message at the very end of the history
D.In the 'stop_sequences' list to prevent the model from deviating
AnswerB

The 'system' parameter is designed specifically for this purpose. It provides the model with the foundational context and constraints it needs to follow. This is the most effective way to define an agent's persona and ensure it adheres to safety and stylistic guidelines consistently.

Why this answer

The system prompt is the dedicated location for high-level instructions that govern the model's behavior throughout the session. By separating these instructions from the user's message, you ensure they remain a persistent influence on the model's reasoning and output style across multiple turns of an agentic loop.

Exam trap

Candidates often incorrectly place persona instructions inside the 'user' message. While this may work for simple prompts, it fails to maintain persistent behavioral constraints across multi-turn sessions or complex agentic tool-use loops.

14
MCQhard

Refer to the exhibit. The provided JSON represents a partial response from Claude. According to the Anthropic API specification for tool use, what is the mandatory next step for the orchestrator to continue the agentic loop?

A.Send a new user message asking the model to ignore the previous tool request.
B.Submit a message with the role 'user' containing a 'tool_result' block matching the tool_use id.
C.Call the 'messages' endpoint again with the same prompt to see if Claude changes its mind.
D.Update the system prompt to include the inventory data discovered by the tool.
AnswerB

The orchestrator must execute the 'query_inventory' function locally and then return the data to Claude. This is done by adding a new message to the history where the role is 'user' and the content contains a 'tool_result' type with the matching 'tool_use_id'.

Why this answer

The Anthropic tool use protocol follows a strict request-response pattern where every 'tool_use' block generated by the model must be acknowledged by the client with a corresponding 'tool_result' block. This ensures that the model's context is updated with the actual outcome of the requested action before it attempts to generate further text.

Exam trap

Candidates often try to send the tool result with the 'assistant' role or omit the matching 'tool_use id', violating the strict alternating message protocol required by the API.

15
MCQmedium

A travel-booking agent built on the Claude Messages API handles multi-turn conversations. During a session, the agent calls a search_flights tool and receives results. On the next user turn the agent suddenly invents a flight that was never returned by any tool. The architect reviews the request payload and sees that the prior assistant turn containing the tool_use block and the following user turn containing the tool_result block were both sent back to the API. What is the most likely cause of the hallucinated flight?

A.The search_flights tool schema declared its parameters as strings while the agent passed integers, so the API silently dropped the returned results.
B.The tool_result block was returned in a separate user message but its tool_use_id did not match the id of the preceding tool_use block.
C.The max_tokens value was too low, which truncated the tool_result content and forced the model to reconstruct the missing flight details.
D.The agent should have cleared the conversation history and resent only the latest user message so the model would not be confused by stale tool output.
AnswerB

When the tool_use_id on the tool_result does not match the id emitted in the assistant's tool_use block, Claude cannot associate the result with the request it made, so the grounded data is effectively invisible to the model and it fills the gap by generating plausible content. Matching ids on every result is the mechanism that keeps tool output authoritative across turns.

Why this answer

Tool results must be bound to the exact tool_use id Claude emitted, otherwise the model treats the returned data as unattached context and fills gaps with invented content. Preserving the assistant tool_use turn and its matching user tool_result turn keeps the grounded data authoritative, so the fix is verifying id correspondence rather than discarding history or tuning token limits.

Exam trap

The trap here is assuming any tool output appended to the conversation is automatically trusted by the model, when only a tool_result carrying the matching tool_use_id is treated as the answer to that specific call.

16
MCQmedium

An architect notices that an agent using Claude 3.5 Sonnet frequently 'hallucinates' tool arguments when the tool schema is very large (over 50 parameters). What is the most effective architectural change to improve tool call accuracy?

A.Switch to Claude 3 Haiku to reduce the cost of the incorrect tool calls
B.Decompose the large tool into several smaller, specialized tools
C.Remove the 'description' fields from the JSON schema to save context space
D.Increase the 'top_p' value to 1.0 to give the model more creative freedom
AnswerB

Breaking down a complex tool into smaller units (e.g., 'update_user_address' and 'update_user_billing' instead of 'update_entire_profile') reduces the cognitive load on the model. This modular approach makes the schemas easier to follow and results in significantly higher reliability and fewer parameter hallucinations in production agentic loops.

Why this answer

Large, complex tool schemas can overwhelm a model's attention, leading to errors in parameter generation. By breaking down a single massive tool into several smaller, more focused tools with fewer parameters, the architect simplifies the reasoning task for the model, making it much more likely to generate valid and accurate arguments for each call.

Exam trap

Candidates attempt to solve tool hallucination by adding more warning instructions in the system prompt, rather than addressing the root cause of bloated tool schemas.

17
Multi-Selectmedium

When implementing a Tool Use (function calling) loop with Claude, which TWO steps are required for the application to successfully complete a multi-step task involving external data?

Select 2 answers
A.Detecting the 'tool_use' stop_reason in the API response
B.Hard-coding the tool results directly into the system prompt
C.Providing the 'tool_result' content block in a subsequent user message
D.Using a temperature setting of 0.0 to ensure tool syntax is correct
E.Manually parsing the model's text output using regular expressions
AnswersA, C

The API indicates that Claude wants to access a tool by returning a specific stop reason. The application must programmatically check for this value to know that it should stop generation, execute the requested local function, and then prepare to send the results back to the model for further reasoning.

Why this answer

In an agentic loop, the application must manage the transition between the assistant's request to use a tool and the provision of the tool's output back to the model. This iterative process requires detecting the specific stop reason and then formatting the external data correctly so Claude can process it in the next turn.

Exam trap

Candidates often forget that tool results must be sent back within a subsequent user message, breaking the required alternating conversational role structure.

18
MCQmedium

In a high-stakes agentic workflow, such as one that executes financial trades, why is 'Human-in-the-Loop' (HITL) considered a critical architectural component?

A.It allows the human to provide more tokens for the model to use
B.It enables the agent to run faster by offloading complex logic to humans
C.It serves as a checkpoint to validate the model's proposed actions
D.It is required by the Anthropic API for all tool-use implementations
AnswerC

By requiring a human to review and approve a tool call before it is executed, the system ensures that the agent's logic aligns with user intent and safety protocols. This is vital for tasks where an error could result in significant financial loss or other serious real-world harm.

Why this answer

Human-in-the-Loop is a safety and quality assurance pattern that inserts a human approval step before an agent performs an action with real-world consequences. This mitigates the risk of model hallucinations or logic errors leading to irreversible mistakes, providing a necessary layer of oversight for sensitive operations.

Exam trap

Candidates sometimes view HITL as a nuisance or a bottleneck. They fail to realize it is a mandatory safety control for preventing irreversible real-world actions in production environments.

19
MCQeasy

A developer wants to build a simple agent that can answer questions about a company's internal documentation. The developer implements a 'Router' that chooses between a 'Search' tool and a 'Direct Answer' prompt. What is the primary advantage of this router-based approach over a single prompt?

A.It allows the model to access the internet without using any tools
B.It eliminates the need for any system prompt or context window management
C.It reduces latency and cost for simple queries by avoiding unnecessary tool calls
D.It guarantees that the model will never hallucinate internal company data
AnswerC

By using a router, the system can identify queries that don't require external data and handle them with a simpler, faster prompt. This avoids the latency of searching documentation when a direct answer is possible, optimizing resource usage and providing a faster response to the user for basic interactions.

Why this answer

Routing is a fundamental agentic pattern that improves efficiency by matching the complexity of the response strategy to the complexity of the user's request. By separating concerns, the architect can optimize individual paths—using a lightweight prompt for simple questions and a more robust, tool-enabled process only when necessary for deeper information retrieval.

Exam trap

Candidates often select overly complex multi-agent architectures for basic tasks, incorrectly believing that more agents always yield higher accuracy, ignoring the latency and cost penalties.

20
Multi-Selecthard

When designing an autonomous agent loop using Claude 3.5 Sonnet that involves tool use, which TWO strategies are most effective for preventing the agent from entering an infinite loop when a tool returns an error?

Select 2 answers
A.Set a strict 'max_iterations' counter in the application logic
B.Increase the temperature setting to 1.0 to encourage varied tool calls
C.Include the specific error message in the 'content' field of the tool_result
D.Use a system prompt that strictly forbids the model from repeating itself
E.Enable prompt caching for every message in the tool-use conversation
AnswersA, C

A hard-coded iteration limit in the orchestration code ensures that the agent cannot run indefinitely, regardless of the model's behavior. This acts as a critical safety circuit-breaker in production systems to control costs and prevent resource exhaustion when the agent fails to converge on a final solution.

Why this answer

Infinite loops in agentic workflows typically occur when an agent repeatedly attempts the same failing action without a strategy change. Implementing a maximum iteration limit provides a hard stop for safety, while providing explicit error feedback in the tool result allows Claude to reason about the failure and attempt a different logical path rather than repeating the same error.

Exam trap

Candidates often ignore the need for hard limits, assuming the model will eventually 'figure it out,' which leads to infinite loops and massive token waste in production environments.

21
MCQhard

Refer to the exhibit. In a parallel tool-use scenario where Claude generates three such blocks in a single response, how should the orchestration layer handle the 'tool_result' messages to ensure Claude can correctly process the outputs?

A.Combine all three tool outputs into a single 'tool_result' block for efficiency
B.Send three separate API requests, each containing one tool result in sequence
C.Return a single 'user' message containing three 'tool_result' blocks with matching IDs
D.Wait for the user to manually approve each tool result before sending them back
AnswerC

This is the correct architectural approach for parallel tool use. By including all results in one 'user' role message, the architect ensures that Claude receives all the requested information at once. Each block must include the 'tool_use_id' that matches the ID from the model's original 'tool_use' request.

Why this answer

Parallel tool use requires that the orchestration layer executes all requested tools and returns a 'tool_result' for each one. Crucially, each result must include the unique 'tool_use_id' generated by the model. This allows Claude to correctly map the data from the external world back to the specific requests it made, maintaining the logical flow of the agent's reasoning.

Exam trap

Candidates often assume multiple parallel tool results should be sent as separate individual messages or missed IDs, failing to group them into a single user message.

22
MCQmedium

A research agent must answer questions that require looking up several unrelated facts, such as the population of three different cities. The architect observes that Claude frequently emits one search tool call, waits for the result, then emits the next, repeating until all facts are gathered. This serial pattern roughly triples latency versus what the workload should allow. Which change most directly enables the model to request all three independent lookups in a single assistant turn?

A.Switch the search tool from a single-query parameter to an array parameter so one call can carry all three queries.
B.Set tool_choice to force a specific search tool on every turn so the model cannot choose to wait between calls.
C.Increase max_tokens so the model has room to write more tool_use blocks before the response is truncated.
D.Add a system instruction that encourages Claude to batch independent lookups by requesting multiple tool calls in the same turn when the queries do not depend on each other.
AnswerD

Claude can already emit several tool_use blocks in one assistant turn; the serial behavior is a planning choice, and prompt-level guidance to parallelize independent calls is the direct, low-cost lever. This preserves the single conversation while collapsing three dependent round trips into one.

Why this answer

Parallel tool use is a capability the model exercises when the calls are independent, and explicit guidance in the system prompt reliably encourages it. The client executes the returned tool_use blocks concurrently and submits all tool_result blocks together, cutting three sequential round trips down to one. No API parameter forces this; it is a prompting and orchestration practice.

Exam trap

The trap here is assuming a parameter or larger token budget will force parallel tool calls, when parallelization is influenced by prompting and by how the client batches results.

23
MCQmedium

Which 'stop_reason' does the Anthropic API return when the model has finished its current thought process and is waiting for the user to provide the results of a tool execution?

A.stop_reason: "end_turn"
B.stop_reason: "max_tokens"
C.stop_reason: "tool_use"
D.stop_reason: "stop_sequence"
AnswerC

This is the correct and specific signal for agentic workflows. It tells the application that the model has generated one or more tool_use blocks and is now pausing its generation specifically to allow those tools to be processed and their results to be returned in the next turn.

Why this answer

The 'tool_use' stop reason is the specific signal from the model that it has reached a point where it cannot proceed without external information. This is the trigger for the application to stop waiting for text and start executing the functions defined in the 'tool_use' content blocks.

Exam trap

Candidates often look for a 'function_call' stop reason. Anthropic's API specifically uses 'tool_use', and failing to catch this specific signal will result in the application ignoring the model's request.

24
MCQhard

Refer to the exhibit showing a configuration for Claude 3.5 Sonnet. Which architectural requirement is strictly necessary when implementing this 'computer_20241022' tool in a production environment?

A.The agent must have direct root access to the host operating system
B.The orchestration layer must include a visual feedback loop for human monitoring
C.The tool must be executed within a dedicated, isolated sandbox or virtual machine
D.The 'display_width_px' must always match the resolution of the developer's monitor
AnswerC

Computer use involves the model executing mouse movements and keystrokes. To ensure security and reliability, these actions must occur in an isolated environment like a Docker container or VM. This prevents the agent from affecting the production server and allows for easy cleanup and reset of the environment.

Why this answer

The 'computer_20241022' tool enables Claude to interact with a graphical user interface by taking screenshots and simulating inputs. Because the model essentially 'sees' the screen, the architect must provide a secure, isolated sandbox environment where the agent can execute commands safely without risking the host system or accessing sensitive data outside the intended scope.

Exam trap

Candidates often overlook security, assuming the tool can be run directly on the host, which poses extreme risks since the model has full control over the system's GUI.

25
Multi-Selecthard

A document-processing agent extracts structured fields from scanned contracts and must return a JSON object matching a strict schema. The agent also calls an OCR tool when text is unreadable. Which TWO design choices best ensure reliable, schema-valid output? (Choose two.)

Select 2 answers
A.Validate the tool input against the JSON Schema in the orchestrator and return a corrective `tool_result` when validation fails.
B.Ask the agent to output the JSON twice and compare the two strings for equality.
C.Set the model temperature to its maximum so the agent explores multiple extraction interpretations.
D.Define a tool whose input schema is the target JSON structure, and instruct the agent to return extracted fields through that tool.
E.Remove the OCR tool so the agent relies solely on the model's vision capability.
AnswersA, D

Even with a schema-bound tool, models can occasionally omit required fields or use wrong types. Validating in the orchestrator and returning an error `tool_result` lets the agent self-correct within the same loop. This creates a closed feedback cycle that raises first-pass validity without human review.

Why this answer

Reliability comes from constraining generation and validating the result. A tool whose input schema matches the target structure forces the model to produce conforming arguments, and orchestrator-side JSON Schema validation with corrective `tool_result` feedback lets the agent fix violations in-loop. Together they replace free-form guessing with a validated, self-correcting extraction step.

Exam trap

The trap here is treating schema compliance as a prompting problem, when it is better solved by constraining output through a schema-bound tool and validating programmatically.

26
MCQeasy

A support agent has two tools: `search_knowledge_base` and `escalate_ticket`. For simple questions it should answer directly; for unresolved issues it should escalate. Which `tool_choice` setting best supports this behavior?

A.`{"type": "none"}`
B.`{"type": "auto"}`
C.`{"type": "any"}`
D.`{"type": "tool", "name": "escalate_ticket"}`
AnswerB

With `auto`, the model decides whether to call a tool or respond directly in text. That matches the scenario, where the agent should answer simple questions without tools and only call `search_knowledge_base` or `escalate_ticket` when needed. It preserves flexibility across both outcomes and is the API default.

Why this answer

The scenario needs the model to choose between answering directly and invoking one of two tools. The `auto` setting lets the model decide per turn, calling a tool only when the question requires it. Forcing any specific tool, or disabling tools, would remove one of the required behaviors.

Exam trap

The trap here is choosing a forced tool setting to make behavior deterministic, when the scenario actually requires the model to decide whether a tool is needed at all.

27
MCQmedium

An architect is building a customer-support agent that calls a `lookup_order` tool. The tool occasionally returns HTTP 503 errors during peak hours. The architect wants the agent to recover from transient failures without human intervention. Which approach best fits Claude's agentic tool-use loop?

A.Terminate the agent turn and return a generic 'service unavailable' message to the end user.
B.Increase the model's `max_tokens` parameter so Claude has more room to reason about the failure.
C.Append a `tool_result` block containing the error message and `is_error: true`, then send the conversation back to Claude so it can decide to retry or try another approach.
D.Silently retry the `lookup_order` call up to five times inside the host application before returning any result to Claude.
AnswerC

This is the canonical way to surface tool failure inside the agentic loop. By returning the error as a tool_result with is_error set, the orchestrator keeps the conversation valid and lets Claude reason about retry, backoff, or fallback, rather than the host application silently retrying and hiding the failure state from the model.

Why this answer

The agentic loop expects every tool_use block to be answered by a matching tool_result. When the underlying call fails, the orchestrator must still reply, marking the result with is_error so the model sees the failure and can plan a retry, fallback, or clarifying question. Hiding or suppressing the error removes Claude's ability to reason about recovery.

Exam trap

The trap here is assuming the host application should absorb retries silently, when in fact the failure must be surfaced to Claude as an error tool_result.

28
Multi-Selectmedium

An architect is evaluating an agent's performance using 'Trajectory Evaluation.' Which TWO aspects of the agent's behavior are most effectively measured by this method?

Select 2 answers
A.The efficiency of the path taken, including the number of redundant tool calls.
B.The exact millisecond latency of the underlying network hardware.
C.The accuracy of the intermediate tool arguments generated by the model.
D.The total number of parameters in the Claude model being used.
E.The aesthetic quality of the UI components used to display the agent's output.
AnswersA, C

Trajectory evaluation allows architects to see if an agent is taking a direct path to the solution or if it is 'wandering'—making unnecessary tool calls or repeating the same actions. Reducing this redundancy is key to optimizing both the cost and the speed of agentic systems.

Why this answer

Trajectory evaluation looks at the entire sequence of steps an agent takes to reach a goal, rather than just the final answer. This is essential for identifying where an agentic loop breaks down, whether it's through inefficient tool use, redundant steps, or logical errors in the reasoning chain.

Exam trap

Candidates frequently confuse output evaluation with trajectory evaluation, measuring only the final response text instead of analyzing intermediate tool arguments and efficiency.

29
MCQhard

An agent that reconciles invoices is failing intermittently. Logs show it sometimes calls `approve_payment` before `verify_vendor`, even though the system prompt lists `verify_vendor` first. The agent has 12 tools available. Which change most directly reduces this ordering violation?

A.Reduce the tool count by removing unrelated tools so the model has fewer choices.
B.Merge `verify_vendor` and `approve_payment` into one tool with a single parameter object.
C.Add a programmatic gate that rejects `approve_payment` calls until a successful `verify_vendor` result exists in the conversation state.
D.Raise the model temperature to encourage more exploratory tool selection.
AnswerC

Enforcing the dependency in the orchestration layer guarantees the invariant regardless of model behavior. Even a well-prompted model can occasionally invert steps, so a deterministic check on conversation state ensures `approve_payment` is only executed after `verify_vendor` succeeds. This is a control, not a suggestion, and it scales as tools grow.

Why this answer

Prompt ordering is a soft hint; models can still invert steps under varying context. The reliable fix is a deterministic guard in the orchestrator that inspects conversation state and blocks `approve_payment` until a valid `verify_vendor` result is present. This preserves the tools' distinct roles while guaranteeing the compliance rule.

Exam trap

The trap here is believing that listing tools in a particular order in the system prompt reliably enforces execution order, when ordering must be enforced programmatically.

30
Multi-Selectmedium

An architect is hardening an agent that uses tools to read internal wikis and send Slack messages. Which TWO practices most directly reduce the risk that untrusted wiki content causes the agent to take unauthorized actions? (Choose two.)

Select 2 answers
A.Raise the model's temperature so the agent explores alternative interpretations of the wiki text.
B.Wrap retrieved wiki content in a clearly delimited block and instruct the model in the system prompt to treat that block as data, never as instructions.
C.Require an explicit human approval step before the agent sends any Slack message whose destination or content is derived from wiki content.
D.Give the agent a single credential with read access to wikis and write access to Slack so it can complete tasks without switching identities.
E.Rely on the wiki's own content moderation to strip malicious instructions before retrieval.
AnswersB, C

Delimiting untrusted content and labeling it as data reduces the chance the model treats embedded text as commands. This is a foundational defense against indirect prompt injection, because it separates the instruction channel from the data channel. It is not a complete solution on its own, but it materially lowers risk when combined with privilege separation.

Why this answer

Two complementary controls break indirect prompt injection: treating retrieved content strictly as data via delimiters and system-prompt framing, and inserting a human approval gate before irreversible actions that were influenced by that content. Together they reduce both the chance of manipulation and the blast radius if manipulation occurs.

Exam trap

The trap here is assuming a single credential with both read and write scopes simplifies the agent, when in fact combining scopes is what lets injected content escalate into unauthorized actions.

31
MCQhard

An agent must classify incoming support tickets and then route each to one of four specialized sub-agents. The architect notices the router sometimes dispatches the same ticket to two sub-agents. Which design change most directly prevents duplicate dispatch?

A.Lower the router's temperature to reduce randomness in classification.
B.Add a system-prompt sentence telling the router to select exactly one category.
C.Increase the number of categories so each ticket has an obvious best match.
D.Give the router a single `route_ticket` tool whose input schema requires one category, and have the orchestrator execute only the first matching tool_use.
AnswerD

Constraining routing to one tool with an enumerated single-value input makes the intended behavior explicit, and orchestrator-side enforcement of a single execution provides a deterministic backstop. Even if the model emits multiple blocks, the host honors only the first, guaranteeing exactly one dispatch per ticket while preserving the model's classification role.

Why this answer

Exactly-once routing is an orchestration invariant. Encode the intent in a single tool with an enumerated category, and enforce it in the host by executing at most one routing tool_use per turn. This combination gives the model a clear decision surface while making duplicate dispatch structurally impossible, regardless of sampling behavior.

Exam trap

The trap here is assuming that a low temperature or a firm prompt guarantees a single tool call, when the guarantee must come from the tool schema and orchestrator enforcement.

32
Multi-Selectmedium

Which TWO practices are recommended when defining tool schemas (JSON descriptions) for an agentic system to improve reliability and reduce errors?

Select 2 answers
A.Using short, cryptic tool names to save input tokens
B.Providing detailed descriptions for every parameter in the schema
C.Always marking all parameters as 'required' to ensure data integrity
D.Including examples of valid inputs within the parameter descriptions
E.Omitting the 'description' field for the tool itself to allow for flexibility
AnswersB, D

Descriptions for parameters act as mini-instructions. By explaining what 'unit' or 'threshold' means and what values are expected, you provide the model with the necessary guidance to format the input correctly, which is especially important for tools with multiple optional or complex arguments.

Why this answer

Well-defined tool schemas are the foundation of effective agentic behavior. Providing clear, descriptive names and detailed property descriptions helps the model understand exactly when and how to use a tool, reducing the likelihood of incorrect parameter values or inappropriate tool selection during complex tasks.

Exam trap

Candidates often provide vague descriptions or omit examples, assuming the model will intuit the schema. This leads to frequent hallucinated parameters and failed tool execution during complex, multi-step agentic workflows.

33
Multi-Selecthard

In an Evaluator-Optimizer agentic workflow, which THREE components are essential for creating a successful iterative refinement loop for high-quality content generation?

Select 3 answers
A.A generator model to produce the initial draft
B.A router to bypass the evaluation for simple tasks
C.An evaluator to provide specific, actionable feedback
D.A parallel worker to execute the feedback simultaneously
E.A feedback loop to pass critiques back to the generator
AnswersA, C, E

The generator is the primary agent responsible for creating the content based on the initial prompt. Without a generator, there is no artifact to evaluate or optimize. It must be capable of following instructions and incorporating feedback in subsequent rounds to improve the overall quality of the final output.

Why this answer

The Evaluator-Optimizer pattern relies on a feedback loop where quality is improved through critique. This requires a generator to produce the initial work, a distinct set of evaluation criteria or a separate model to provide feedback, and a mechanism to feed that feedback back into the generator for the next iteration.

Exam trap

Candidates fail to include a clear feedback mechanism in optimization loops, resulting in an open-ended loop where the generator repeats the exact same mistakes.

34
MCQhard

An architect is designing an agentic workflow on the Anthropic Messages API where a single Claude model must first break a user goal into ordered subtasks, then execute each subtask with tools, and finally synthesize a final answer. The architect wants to minimize the number of API round trips while still giving the model a chance to observe each tool result before deciding the next action. Which orchestration approach best satisfies these requirements?

A.Issue one request that asks Claude to output the entire plan plus every tool call in a single assistant turn, then execute all tools in parallel and return all results in one user turn.
B.Enable extended thinking with a high budget_tokens value and instruct Claude to simulate each tool's output internally, returning only the synthesized final answer without invoking any tools.
C.Use a single request with a stop sequence on the tool_use block, execute the requested tools, then send a follow-up user message containing the tool_result blocks and repeat until Claude returns a final text response.
D.Create a separate Claude conversation for each subtask, passing the full prior transcript as a system prompt so each conversation can plan independently before returning its result to an orchestrator.
AnswerC

This is the standard agentic tool-use loop: Claude emits tool_use blocks, the application executes them, and tool_result blocks are returned in a new user turn so Claude can observe outcomes and decide the next step. Iterating until a final text response naturally supports plan, execute, and synthesize phases while keeping each decision grounded in fresh observations, which is exactly what the scenario demands.

Why this answer

The agentic tool-use loop is the correct orchestration pattern because it alternates model reasoning with real tool execution, letting Claude observe each tool_result before selecting the next action. This supports decomposition, execution, and final synthesis in one evolving conversation. Batching all calls, splitting into separate conversations, or simulating tool outputs each break the observe-then-decide contract or inflate cost and latency without satisfying the stated constraints.

Exam trap

The trap here is assuming that fewer API round trips always means better orchestration, when the observe-then-decide loop is what actually enables reliable multi-step tool use.

35
MCQmedium

An architect is designing a Claude agent that must autonomously handle customer disputes end to end. The agent may issue refunds up to $200, but any refund above that amount must be approved by a human reviewer. The system must not block the entire workflow while waiting for approval. Which orchestration pattern best satisfies these constraints?

A.Have the agent call a refund tool that internally pauses the HTTP request until a human approves, then returns the result in the same tool_result.
B.Route all disputes to a queue processed only by humans, removing the agent from the approval path entirely.
C.Instruct the agent in the system prompt to always ask the customer to wait while it internally polls the approval service every few seconds.
D.Model the refund as a tool that returns a pending status plus a case identifier, persist the agent state, and resume the conversation when the human decision arrives.
AnswerD

Returning a pending status with a case identifier lets the agent stop cleanly without blocking, and persisting state allows the conversation to resume when approval arrives. This is the standard durable-execution pattern for human-in-the-loop agents: the tool reports an intermediate outcome, the orchestrator stores the messages array, and a later event injects the decision as a new tool_result to continue reasoning.

Why this answer

Human-in-the-loop patterns work best when the agent yields rather than blocks. A refund tool that returns a pending status with a case identifier lets the orchestrator persist the conversation and resume it when the reviewer decides. This keeps the workflow responsive, avoids tying up connections, and cleanly injects the approval or denial back into the agentic loop as a new tool_result.

Exam trap

The trap here is assuming the agent can wait or poll in the background, when in reality the API is stateless and the pause must be implemented by the orchestrator, not the model.

36
MCQmedium

A production agent uses the Claude Messages API with tool use to manage cloud resources. During a run, Claude returns a response whose stop_reason is "tool_use" containing three tool_use content blocks that are fully independent of one another. The orchestrator loops and processes them one at a time, executing each tool and sending a separate user message containing a single tool_result block before each next call. Runs that used to complete in seconds now take minutes and occasionally exceed the request timeout. What is the most likely architectural cause of the slowdown?

A.The orchestrator should have set the max_tokens parameter higher before executing the tools, because low token limits cause the API to throttle subsequent tool_result submissions.
B.The stop_reason value "tool_use" indicates the model is waiting for the client to switch to the streaming endpoint before any tool can be executed.
C.Each tool_result block was sent in its own user message, so Claude had to re-ingest the full conversation and re-plan after every individual tool instead of receiving all three results together in one user message.
D.Independent tool_use blocks must be executed in the exact order they appear in the assistant message, and any out-of-order execution invalidates the context window.
AnswerC

This is correct because the Messages API expects all tool_result blocks for a given assistant turn to be returned together in a single user message. Splitting them forces three extra model round trips, each re-processing the whole context, which inflates latency and can push the run past the request timeout.

Why this answer

When a single assistant turn requests several independent tools, the client should execute them and return every matching tool_result block in one user message keyed by tool_use_id. Returning results piecemeal forces additional model calls that each reprocess the conversation, multiplying latency and token cost. Batching the results restores one planning step per assistant turn.

Exam trap

The trap here is assuming each tool_result needs its own follow-up message, when the API expects all results for an assistant turn to be batched into a single user message.

37
MCQhard

A security audit of an agentic architecture reveals a risk of 'Indirect Prompt Injection' where the agent reads a malicious email and then uses its 'delete_account' tool on itself. Which architectural change best mitigates this risk?

A.Adding a sentence to the system prompt telling Claude to ignore instructions in emails.
B.Implementing a separate 'Sandboxed Guardrail' agent to pre-scan all incoming data for commands.
C.Moving sensitive tools like 'delete_account' to a 'Human-in-the-Loop' approval workflow.
D.Encoding all email text into a format like Base64 before showing it to the agent.
AnswerC

The most secure architectural choice is to remove the model's autonomy for irreversible or high-risk actions. By requiring a human to click 'Approve' on a dashboard before the 'delete_account' tool actually executes, you create a physical barrier that prompt injection cannot bypass.

Why this answer

Indirect prompt injection occurs when a model treats untrusted data (like an email) as a set of instructions. To prevent this, architects must separate the data from the instructions, use strict tool schemas, and implement 'Human-in-the-Loop' for high-impact tools to ensure that the agent's actions are always verified.

Exam trap

Candidates often suggest technical fixes like prompt sanitization or input filtering, which are insufficient against sophisticated indirect injections; they overlook the necessity of human-in-the-loop for high-stakes actions.

38
MCQmedium

An agent is designed to summarize long documents by first splitting them into chunks and then calling a 'summarize_chunk' tool for each part. What is the most efficient orchestration strategy to minimize the total time taken for this task?

A.Sequential execution where each chunk is processed only after the previous one finishes.
B.Instructing Claude to summarize all chunks in a single, very long 'text' block without tools.
C.Asynchronous parallel tool calls managed by the orchestrator for all chunks simultaneously.
D.Recursive orchestration where the agent calls itself to summarize each new chunk.
AnswerC

By triggering all 'summarize_chunk' calls at once, the orchestrator can process them in parallel. This leverages the concurrency capabilities of the environment and the API, ensuring that the total time is limited by the single longest-running chunk rather than the sum of all chunks.

Why this answer

In workflows where tasks are independent, such as summarizing different parts of a document, sequential execution is unnecessarily slow. Orchestrating these calls in parallel allows the system to utilize the full throughput of the API, significantly reducing the 'wall-clock' time required to complete the overall job.

Exam trap

Candidates frequently choose sequential processing because it seems safer or easier to debug, failing to recognize that independent tool calls should always be parallelized to optimize latency and throughput.

39
MCQhard

A team runs a Claude agent that orchestrates a multi-step data pipeline. The agent uses the Messages API and passes the full conversation history on every request. After the history grows beyond roughly 180,000 tokens, the agent begins to fail intermittently with context length errors even though the configured model supports 200,000 tokens. Logs show the agent appends each tool result verbatim, including large JSON payloads from a database tool. Which change best resolves the failures while preserving the agent's ability to reason over prior steps?

A.Reduce max_tokens on each request so the combined prompt plus completion fits under the model limit.
B.Enable prompt caching on the system prompt and tool definitions so repeated prefixes are billed and processed more efficiently.
C.Move the entire conversation history into a single user message and ask Claude to ignore irrelevant portions.
D.Summarize or truncate older tool_result blocks before appending new turns, keeping only the fields the agent needs from large database payloads.
AnswerD

The overage comes from verbatim large JSON tool results accumulating in history. Compressing or summarizing older tool_result content, and trimming payloads to relevant fields, reduces input tokens per request while retaining the semantic content the agent needs to reason about prior steps. This directly addresses the context length failures and preserves continuity better than discarding history entirely.

Why this answer

Context length failures stem from unbounded accumulation of verbatim tool results, not from the model's advertised maximum. Compressing or summarizing older tool_result blocks, and trimming large JSON payloads to only relevant fields, lowers input tokens per request while preserving the reasoning trail. Caching and max_tokens tuning affect cost or output reservation, not the input footprint, so they cannot resolve the overage.

Exam trap

The trap here is treating prompt caching or lower max_tokens as fixes for context overflow, when only reducing the accumulated input tokens actually solves it.

40
MCQeasy

An architect is configuring a Claude agent that must decide when to search an internal knowledge base versus when to answer directly from its own knowledge. The team wants the agent to retrieve only when the question references internal policies, products, or procedures. Which configuration most directly supports this decision?

A.Register the search tool but instruct Claude to call it only when the user explicitly types the word search.
B.Set tool_choice to auto and provide a well-described search tool so Claude decides per turn whether retrieval is needed.
C.Disable tools entirely and rely on a large system prompt containing the most frequently asked policy excerpts.
D.Set tool_choice to any and register only the knowledge base search tool so the model must always retrieve before answering.
AnswerB

With tool_choice set to auto, Claude evaluates the user's request and the tool description each turn and emits a tool_use block only when the description matches the need. A clear description explaining that the tool covers internal policies, products, and procedures gives the model the signal it needs to retrieve selectively rather than on every turn.

Why this answer

Selective retrieval is achieved by letting the model decide per turn using tool_choice auto plus a precise tool description. The description tells Claude what content the tool covers, so it invokes search for internal policy, product, or procedure questions and answers directly otherwise. Forcing tool use, disabling tools, or gating on a keyword all remove that contextual judgment and produce either over-retrieval or missed retrieval.

Exam trap

The trap here is conflating tool_choice any with auto; forcing any guarantees retrieval on every turn, which is the opposite of selective retrieval.

41
MCQhard

An orchestration layer runs a research agent that can call a web_search tool and a summarize_document tool. The architect wants the agent to keep iterating until it has gathered enough sources, but must cap total model calls and total tool executions to control cost and prevent runaway loops. Which approach best enforces those caps while preserving the agent's ability to decide when it is done?

A.Set a very high max_tokens on every request so Claude naturally stops once it has written enough, avoiding the need for an explicit iteration limit.
B.Instruct Claude in the system prompt to stop after at most ten tool calls and trust the model to count its own invocations accurately.
C.Configure the tools with a strict input_schema so malformed arguments cause the API to reject extra calls once a threshold is reached.
D.Wrap the loop in application code that counts iterations and tool calls, stops when either budget is exhausted, and lets Claude signal completion by returning a final answer with no tool_use block.
AnswerD

The orchestrator owns the loop, so it can track model calls and tool executions against explicit budgets and halt deterministically when a cap is hit. Letting Claude finish by returning a normal response with no tool_use block preserves model-driven completion within those bounds, combining hard cost control with flexible termination.

Why this answer

Hard cost and safety limits belong in the orchestrator, which can count model calls and tool executions and stop deterministically at a budget boundary. Allowing Claude to end the loop by returning a response with no tool_use block keeps the agent in control of when its task is complete, so the two mechanisms together give bounded but adaptive behavior.

Exam trap

The trap here is relying on prompt instructions or max_tokens to bound an agent loop, when only host-side counters can actually enforce an iteration or execution budget.

42
MCQmedium

An agentic system is designed to use a search tool to find information. During testing, the agent occasionally gets stuck in a loop, repeatedly calling the same search tool with the same parameters. What is the most effective way to prevent this behavior programmatically?

A.Increase the model's top-p value to encourage variety
B.Implement a maximum iteration counter in the application logic
C.Reduce the system prompt length to simplify instructions
D.Change the model from Claude 3.5 Sonnet to Claude 3 Haiku
AnswerB

A maximum iteration limit is a robust programmatic safeguard. By tracking how many times the model has called a tool in a single session, the application can force the loop to terminate if a threshold is reached, preventing infinite loops and providing a graceful fallback or error message.

Why this answer

Infinite loops are a common risk in agentic architectures where the model believes it hasn't found the right answer. Implementing a hard limit on the number of iterations and tracking the history of tool calls are standard safety measures to prevent runaway token usage and ensure the system remains responsive.

Exam trap

Candidates frequently suggest prompt-based solutions like 'tell the model not to loop.' This is unreliable; programmatic constraints like iteration counters are required to guarantee the system stops regardless of model reasoning.

43
MCQmedium

A research agent must query three independent sources (a database, a web search API, and a file store) to assemble a report. Latency matters, and the sources do not depend on each other. Which orchestration pattern should you use with Claude's tool use to minimize wall-clock time?

A.Three separate agents, each with one tool, coordinated by a fourth router agent.
B.Sequential single-tool turns, where each result is returned before the next tool is requested.
C.A single completion in which the model emits three `tool_use` blocks, followed by one user turn containing three `tool_result` blocks.
D.Set `tool_choice` to `{"type": "tool", "name": "web_search"}` so the fastest tool runs first.
AnswerC

The Messages API supports parallel tool use: the model can emit multiple `tool_use` blocks in one assistant turn, and the application executes them concurrently and returns all `tool_result` blocks together. For independent sources, this overlaps execution and removes serial round trips, directly reducing wall-clock time while preserving correct id linkage.

Why this answer

Parallel tool use lets Claude emit several `tool_use` blocks in one response. The application runs the independent calls concurrently and returns all results in a single user turn, each tied to its `tool_use_id`. For a report assembled from unrelated sources, this overlaps latency and avoids serial model round trips.

Exam trap

The trap here is assuming each tool call must be its own model turn, when the API allows multiple `tool_use` blocks in one response that can be executed concurrently.

44
MCQmedium

A company is deploying an agent that interacts with a sensitive financial database. To maintain security and accuracy, the architect wants to ensure that any 'delete' or 'transfer' actions are reviewed by a human before execution. Which agentic pattern should be used?

A.Parallel Tool Execution to allow the model to run multiple checks simultaneously.
B.The ReAct pattern to allow the model to think before it acts on the database.
C.An 'Interrupt-and-Approve' orchestration loop for specific tool definitions.
D.Increasing the frequency of system prompt injections to remind the model of the rules.
AnswerC

This pattern involves the application logic intercepting specific tool calls identified as 'sensitive.' The orchestrator pauses the agent's progress, presents the proposed tool arguments to a human user, and only proceeds to send the 'tool_result' back to Claude once the human has provided explicit approval.

Why this answer

Human-in-the-loop (HITL) is a critical design pattern for agentic systems operating in high-stakes environments. It allows the model to propose actions while reserving the actual execution for a human-verified trigger. This mitigates the risk of autonomous errors and ensures that the agent operates within the safety guardrails of the organization.

Exam trap

Test-takers often confuse automatic error-retry loops with security checkpoints, selecting generic error handling instead of human-in-the-loop patterns for high-stakes actions.

45
MCQeasy

A team wants Claude to call an internal `create_invoice` tool only after the user has explicitly approved the line items. Which mechanism should the architect use to enforce this gate?

A.Withhold the `create_invoice` tool definition from the request until the orchestrator records explicit user approval, then include it in a subsequent turn.
B.Use a system prompt instructing Claude to always ask for confirmation before calling `create_invoice`.
C.Set `tool_choice` to force a specific tool so Claude cannot pick anything else.
D.Set `tool_choice` to `auto` so Claude decides when to call `create_invoice`.
AnswerA

Tools that are not in the request cannot be called. By gating the tool definition behind an approval flag in the host application, the architect enforces the policy structurally rather than relying on model compliance. After consent, the tool becomes available and Claude can proceed normally within the same conversation.

Why this answer

Enforce business-critical gates in the orchestrator, not in prompts. If the create_invoice tool is absent from the request, the model cannot emit a tool_use for it. Once the host records explicit approval, the tool definition is added and the conversation continues, giving the architect deterministic control over a sensitive side effect.

Exam trap

The trap here is believing a strong system-prompt instruction is sufficient to prevent an unauthorized tool call, when the reliable control is removing the tool from the request.

46
MCQmedium

An architect is building a Claude agent that must extract structured data from scanned invoices and then call an ERP API for each invoice. During early testing, the agent occasionally calls the ERP API with incomplete fields because it invents missing values. The architect wants to prevent these hallucinated field values from reaching the ERP. Which approach best addresses this requirement using the Anthropic Messages API?

A.Switch the model to a smaller Claude Haiku variant to reduce creative generation, and rely on the ERP API's own field validation to reject bad submissions.
B.Define the ERP submission tool with a strict JSON Schema that marks required fields and adds a second validation tool Claude must call before erp_submit to confirm extracted values against the source text.
C.Increase the max_tokens value and add a system prompt instructing Claude to be accurate when reading invoices, then enable streaming so partial tool inputs arrive faster.
D.Set the tool_choice parameter to {"type": "tool", "name": "erp_submit"} so Claude must call the ERP tool on every turn, and validate the fields inside the ERP tool handler.
AnswerB

A strict input_schema with required fields and constrained types forces Claude's tool_use block to conform structurally, and a preceding verification tool that re-checks extracted values against the source text surfaces discrepancies before the ERP call. Together they reduce hallucinated values reaching downstream systems, which is exactly the architect's stated goal for scanned invoice extraction.

Why this answer

Tool schemas in the Anthropic Messages API constrain the shape of tool_use input, so required fields and typed values are enforced structurally. Pairing that with an explicit verification step before the ERP tool closes the loop on values Claude could not actually read from the scan. Increasing tokens, streaming, or relying on downstream ERP validation leaves hallucinated content in the pipeline and does not satisfy the goal of preventing invented fields from reaching the ERP.

Exam trap

The trap here is assuming that forcing a specific tool_choice or switching to a smaller model will eliminate hallucinated field values, when only schema constraints plus source verification actually address the problem.

47
MCQeasy

When designing a multi-agent system, what is the primary benefit of the 'Orchestrator-Worker' pattern compared to a single-agent architecture with 20 tools?

A.It eliminates the need for a system prompt for the worker agents.
B.It reduces the complexity of the orchestrator's context window by offloading details to workers.
C.It allows the model to bypass the per-token pricing of the Anthropic API.
D.It guarantees that the model will never produce a hallucinated tool name.
AnswerB

By delegating tasks, the orchestrator only needs to know which worker to call and the final result they provide. This keeps the orchestrator's context window clean of the minute details and intermediate tool outputs used by the workers, reducing noise and the risk of the model getting distracted.

Why this answer

As the number of tools increases, the complexity of the prompt and the likelihood of tool selection errors grow. The Orchestrator-Worker pattern simplifies the individual prompts by delegating specific tasks to specialized agents, which improves accuracy and makes the overall system easier to debug and maintain.

Exam trap

Candidates tend to choose monolithic single-agent architectures with dozens of tools, underestimating the context degradation and confusion caused by bloated prompt schemas.

48
MCQeasy

In the context of agentic orchestration, what is the primary purpose of a 'ReAct' (Reason-Act) loop?

A.To allow the model to rewrite its own system prompt dynamically during execution.
B.To encourage the model to verbalize its internal reasoning before executing a tool.
C.To reduce the latency of the API response by skipping the output of text blocks.
D.To provide a way for the model to access historical data that was not included in the context window.
AnswerB

By forcing Claude to 'think' out loud, the ReAct pattern leverages the model's autoregressive nature. The generated 'Thought' tokens act as a form of working memory, helping the model stay on track and reducing errors by ensuring the reasoning logic is established before the tool call is generated.

Why this answer

The ReAct pattern combines reasoning and acting by prompting the model to generate a 'Thought' before a 'Tool Use.' This approach improves the model's ability to plan, adjust to new information, and explain its decision-making process, making the agent more transparent and reliable in complex scenarios.

Exam trap

Candidates often assume ReAct is just about letting the model use tools, ignoring the 'Reason' component entirely, which leads to failing to understand why the model needs to verbalize its internal state.

49
Multi-Selecthard

A claims-processing agent must extract structured fields from scanned documents, then decide whether to auto-approve, request more evidence, or escalate to a human. The architect wants deterministic, auditable control over which branch executes rather than letting Claude narrate the decision. Which TWO design choices best achieve that? (Choose two.)

Select 2 answers
A.Allow Claude to call any of the organization's internal APIs directly so it can decide the branch at execution time without orchestrator involvement.
B.Instruct Claude in the system prompt to begin every response with the word APPROVE, EVIDENCE, or ESCALATE, then parse that prefix in application code.
C.Have Claude return a JSON object with a decision field and validate it against a schema before acting on it.
D.Set temperature to its maximum so the agent explores all possible decision branches before committing to one.
E.Define discrete tools such as approve_claim, request_evidence, and escalate_to_human, and use the tool the model selects as the routing signal.
AnswersC, E

A schema-validated decision field gives the orchestrator a single typed value to switch on and rejects malformed outputs before any action fires. Validation turns an otherwise soft model output into a contract, so unexpected or missing fields fail loudly instead of triggering an unintended branch. Combined with a defined enum of decisions, this yields deterministic, auditable routing.

Why this answer

Deterministic, auditable branching comes from making the decision an explicit structured signal the orchestrator can inspect and validate before acting. Either a small set of named tools or a schema-validated decision field turns the model's choice into a typed, loggable value, whereas text conventions, temperature tuning, and unmediated API access all leave the branch implicit or uncontrolled.

Exam trap

The trap here is treating a reliably phrased sentence from the model as equivalent to a validated structured decision, when only typed outputs can be rejected before an irreversible action fires.

50
Multi-Selectmedium

An architect is designing a multi-step research agent that must gather facts, draft a report, and revise it based on a critique. The team wants to reduce the blast radius of mistakes and keep each stage's context focused, rather than letting one long conversation accumulate every intermediate result. Which TWO design choices best support this goal? (Choose two.)

Select 2 answers
A.Give each stage its own focused prompt and pass only the artifacts it needs, such as the fact list into the drafting stage, instead of replaying the entire history.
B.Add a validation or critique step between stages that checks the artifact against explicit criteria before it is allowed to feed the next stage.
C.Remove all tools from the drafting and revision stages so the agent is forced to rely only on its parametric knowledge.
D.Run every stage with the highest available temperature so the agent explores many alternatives and the strongest output naturally survives.
E.Persist the entire conversation transcript and re-send it unchanged on every stage so no historical detail is ever lost.
AnswersA, B

Scoping each stage's prompt and inputs keeps the context small and relevant, which lowers the chance that an early error contaminates later reasoning. It also makes each stage independently testable and cheaper to run, directly supporting the goal of a smaller blast radius.

Why this answer

Isolating stages behind focused prompts limits what each step can see and corrupt, while an explicit validation gate stops defective artifacts from propagating. Together they confine failures to a single stage and keep context tight. These two practices deliver the containment the team wants without sacrificing the agent's access to tools or knowledge.

Exam trap

The trap here is assuming that preserving the full transcript or maximizing randomness improves robustness, when containment actually comes from scoped context and inter-stage validation.

51
MCQhard

A large-scale agentic system uses Claude to manage a supply chain. The agent must interact with a legacy SQL database, a modern REST API, and a real-time streaming service. What is the most robust way to handle tool definitions in this heterogeneous environment?

A.Provide the model with the raw SQL schema and API documentation in the system prompt
B.Create a unified 'execute_command' tool that accepts raw strings for any service
C.Define separate, strongly-typed tools with clear descriptions and parameter schemas
D.Use a single 'agent_proxy' tool that asks a human to execute the tasks manually
AnswerC

This is the best practice for agentic tool use. By defining separate tools (e.g., 'query_inventory_db', 'update_shipping_api'), the architect provides the model with clear boundaries and instructions for each service. The orchestration layer then maps these structured calls to the appropriate database queries or API requests.

Why this answer

In complex environments, tool definitions act as the interface between the LLM and various technical stacks. To ensure robustness, the architect should define clear, narrow tool schemas that abstract the underlying complexity, providing Claude with a consistent JSON interface while the orchestration layer handles the specific protocols and authentication for each backend system.

Exam trap

Candidates often try to expose raw, unstructured database schemas directly to the LLM, leading to high error rates instead of properly abstracting tool definitions.

52
MCQhard

A document-processing agent reads contracts and must extract a list of payment milestones, each with an amount, currency, and due date. Downstream billing systems cannot tolerate hallucinated fields, and the extraction must be validated programmatically before anything is written to the database. The architect wants Claude to emit data that can be parsed and checked with certainty rather than relying on post-hoc regex over prose. Which approach best satisfies this requirement?

A.Instruct Claude in the system prompt to reply only with JSON and add a reminder to double-check every field before answering.
B.Define a tool whose input_schema describes the milestone array with required amount, currency, and due date fields, and force Claude to call it using tool_choice.
C.Raise the temperature to encourage variety and then filter the results with a second Claude call that rewrites non-conforming records.
D.Use a very large max_tokens value and ask Claude to include the milestones in a markdown table so a parser can split on pipe characters.
AnswerB

A tool's input_schema is a JSON Schema the API validates the generated arguments against, and setting tool_choice to that tool forces the model to produce a structured call. The client receives typed, parseable input it can validate field by field before any database write, which is exactly the guarantee required.

Why this answer

Tool definitions carry a JSON Schema in input_schema, and tool_choice can force the model to emit arguments conforming to that schema rather than free text. The client then validates the structured fields before persisting them, giving a deterministic contract that prompt wording alone cannot provide. This is the standard pattern for extraction feeding strict downstream systems.

Exam trap

The trap here is treating a well-written JSON instruction as equivalent to a schema-enforced tool call, when only the latter gives the client a machine-checkable contract.

53
MCQmedium

A financial services company is building a customer support assistant that needs to handle loan applications, account balance checks, and general FAQ queries. Which orchestration pattern should be used to minimize token usage while ensuring that the model uses specific system instructions for each distinct task?

A.The Parallelized Workflow pattern
B.The Router pattern
C.The Evaluator-Optimizer pattern
D.The Autonomous Agent pattern
AnswerB

Routing allows the system to identify the specific domain of a query before applying detailed logic. By selecting a specialized prompt or toolset based on the classification, the architecture maintains high precision for complex tasks like loan applications while keeping the context window focused and cost-effective for simpler queries.

Why this answer

The Router pattern is ideal for this scenario because it uses a primary model to classify the user's intent and then routes the request to specialized sub-processes or distinct system prompts. This prevents the need for a single, massive system prompt containing all instructions, which reduces input token costs and improves the accuracy of the specialized responses.

Exam trap

Candidates often recommend stuffing all system instructions into a single monolithic prompt, ignoring the scaling costs and token overhead of heterogeneous tasks.

54
Multi-Selectmedium

When implementing the 'Evaluator-Optimizer' pattern for code generation with Claude 3.5 Sonnet, which TWO components are essential for the feedback loop to be effective?

Select 2 answers
A.A distinct set of evaluation criteria or unit tests for the code
B.The use of two different model families to ensure diversity of thought
C.A mechanism to pass the evaluator's feedback back to the generator
D.Setting the temperature to 0 for both the generator and the evaluator
E.A mandatory human approval step after every single model iteration
AnswersA, C

Without objective criteria, the evaluator cannot provide consistent or helpful feedback. In code generation, this often takes the form of unit tests or linter rules. These criteria ensure that the optimizer is working toward a measurable goal of quality rather than making arbitrary changes to the code.

Why this answer

The Evaluator-Optimizer pattern relies on a clear separation of generation and critique. To be effective, the evaluator must have a set of objective criteria or tests to check the generator's work, and the generator must receive the specific results of that evaluation to make targeted improvements in the next iteration of the loop.

Exam trap

Candidates often forget that an evaluator needs a structured mechanism to communicate errors back, rather than just returning a binary pass/fail status without actionable details.

55
MCQmedium

Refer to the exhibit. What is the correct next step for the application developer to ensure the agent continues its task?

A.Ask the user to manually verify the ticker symbol before proceeding
B.Send a new user message containing only the raw numeric stock price
C.Execute the function and return a tool_result block with the tool_use_id
D.Re-submit the original prompt with a higher temperature to get the price
AnswerC

This is the standard protocol for Anthropic tool use. The application must extract the parameters, run the local code, and then provide the output back to the model in a structured format. Using the correct ID ensures the model can continue its chain of thought and successfully finalize the response.

Why this answer

The exhibit shows a standard tool_use response from the Messages API. To proceed, the developer must execute the 'get_stock_quote' function locally using the provided input, and then send a new request to Claude containing a message with the 'tool_result' block that references the unique ID 'toolu_01A2B3C4'.

Exam trap

Candidates mistakenly try to continue the conversation by sending the function output as an 'assistant' message instead of formatting it as a 'tool_result' block.

56
MCQmedium

An agent tasked with data analysis repeatedly fails because the 'tool_result' it receives is too large for the context window, causing subsequent calls to truncate. What is the most effective architectural adjustment to resolve this?

A.Switch to a model with a smaller context window to force more efficient coding.
B.Use the 'tool_result' to return a summary or a file path instead of the full raw data.
C.Format the tool output as a series of multiple user messages to spread the load.
D.Request that Claude only uses the last 100 lines of the tool output in its reasoning.
AnswerB

Returning a summary allows Claude to understand the key characteristics of the data without overwhelming its context window. If the model needs specific details, it can then use a different tool to query a specific subset of the data, maintaining a high signal-to-noise ratio in the conversation.

Why this answer

Large tool outputs can quickly consume the context window, leaving no room for the model's reasoning or future tool calls. Architects should implement a 'Summarize-or-Reference' pattern where the full data is stored externally and only a concise summary or a pointer is returned to the agent within the message history.

Exam trap

Candidates frequently assume that passing raw, large datasets directly back into the context window is safe, ignoring context length limitations and truncation risks.

57
Multi-Selecthard

An architect is designing a Claude agent that must coordinate a research subagent and a summarization subagent to produce a market brief. The research subagent gathers sources, and the summarization subagent condenses them. The architect wants to avoid the orchestrator losing track of which subagent produced which artifact across many turns. Which TWO architectural practices best support reliable artifact tracking and handoff? (Choose two.)

Select 2 answers
A.Concatenate all subagent outputs into a single summary string before appending them to the orchestrator's history.
B.Rely on the orchestrator's system prompt to remember which subagent produced each artifact without adding identifiers.
C.Give each subagent a distinct tool name and require its results to be returned as tool_result blocks tied to a unique tool_use_id.
D.Increase the orchestrator's temperature so it explores multiple attribution hypotheses before choosing one.
E.Embed the subagent identity inside each artifact as structured metadata fields alongside the content payload.
AnswersC, E

Distinct tool names plus unique tool_use_id values create an explicit, machine-checkable link between each request and its result. The orchestrator can map every artifact to the subagent that produced it without relying on prose in the model's output. This directly prevents misattribution across many turns and keeps the conversation history auditable.

Why this answer

Reliable multi-subagent handoff depends on explicit, structured provenance rather than model inference. Unique tool names and tool_use_id linkage bind each result to its requesting subagent, while metadata embedded in artifacts keeps identity attached even after summarization or storage. Raising temperature, concatenating outputs, or trusting the system prompt to remember provenance all remove or weaken those structural guarantees, making misattribution more likely across many turns.

Exam trap

The trap here is assuming the orchestrator can remember provenance from context alone, when durable attribution requires explicit identifiers and metadata rather than model recall.

58
MCQhard

An architect is designing an agentic system to handle complex software engineering tasks. The system must break down a high-level requirement into specific coding milestones, assign those milestones to specialized sub-agents, and synthesize the results. Which orchestration strategy is most appropriate?

A.The Chain-of-Thought Sequential pattern
B.The Router pattern
C.The Orchestrator-Worker pattern
D.The Parallel Voting pattern
AnswerC

This pattern excels at managing complexity by allowing a central model to act as a project manager. The orchestrator analyzes the top-level goal, breaks it into discrete sub-tasks for workers, and then combines their outputs. This provides the necessary flexibility to handle unpredictable software development cycles and cross-component dependencies.

Why this answer

The Orchestrator-Worker pattern is specifically designed for complex, non-deterministic tasks where the central model must dynamically plan and delegate work. Unlike a simple router, the orchestrator monitors the progress of sub-tasks and synthesizes the outputs into a coherent final result, making it the superior choice for multi-step engineering projects.

Exam trap

Candidates frequently confuse the Router pattern with the Orchestrator-Worker pattern, failing to recognize when a task requires hierarchical task decomposition and synthesis.

59
MCQhard

You are building an agent that needs to summarize 50 different documents. Which orchestration approach provides the best balance between speed and the model's ability to cross-reference information between all documents?

A.Feeding all 50 documents into a single prompt for one summary
B.A sequential chain where each document is added one by one
C.Parallel processing of summaries followed by a synthesis step
D.An autonomous agent that decides which document to read next
AnswerC

This approach uses parallel workers to summarize individual documents simultaneously, which drastically reduces total processing time. A final pass then takes these concise summaries and synthesizes them, allowing the model to cross-reference the key points efficiently without needing to re-read every full document at the end.

Why this answer

For a task involving many documents, a hybrid approach is best. Parallel processing allows for fast individual summarization, but a final synthesis step (Orchestrator) is required to cross-reference and unify the information. This prevents the model from being overwhelmed by too much text in a single context window while ensuring global coherence.

Exam trap

Candidates often choose a single-pass approach by stuffing all documents into one context window. This risks hitting token limits and causes the model to lose focus on specific document details.

60
MCQeasy

What is the recommended temperature setting for an agent that primarily uses tools to perform data extraction and API calls?

A.Temperature 1.0
B.Temperature 0
C.Temperature 0.7
D.Temperature -1.0
AnswerB

Setting the temperature to 0 makes the model's output more deterministic. This is the best practice for agents because it ensures that the model consistently chooses the most likely (and usually most correct) token, leading to more stable and reliable tool use and logical reasoning across multiple steps.

Why this answer

For agentic tasks where structural integrity and logical consistency are paramount, a temperature of 0 is recommended. This minimizes randomness in the model's output, ensuring that tool calls follow the required schema exactly and that the reasoning steps remain deterministic and reproducible during debugging.

Exam trap

Candidates often assume a higher temperature is needed for 'creativity.' In agentic workflows, creativity is a liability; non-deterministic outputs lead to malformed tool calls that crash the integration layer.

61
Multi-Selectmedium

An orchestrator is designed to handle 'Parallel Tool Use' for a travel booking agent. Which TWO conditions must be met for the architect to successfully implement this feature?

Select 2 answers
A.The tools being called must not have sequential dependencies on each other's outputs.
B.The model must be instructed to use a single 'tool_result' block for all outputs.
C.The orchestrator must be capable of processing the model's response which contains multiple 'tool_use' blocks.
D.The 'temperature' must be set to 0 to ensure the tools are called in alphabetical order.
E.A human must manually approve the parallel execution via a dedicated CLI tool.
AnswersA, C

Parallel execution is only possible if the model can generate all necessary arguments at once. If Tool B requires an ID generated by Tool A, they must be called sequentially across two different turns of the agentic loop, as the model cannot know the result of Tool A beforehand.

Why this answer

Parallel tool use allows Claude to suggest multiple actions in a single response, which can significantly reduce latency in complex workflows. To use this effectively, the architect must ensure the tools are independent of one another and that the application can handle and respond to multiple 'tool_use' IDs simultaneously.

Exam trap

Test-takers often attempt parallel tool execution even when tools have data dependencies, leading to race conditions and incorrect sequential logic execution.

Ready to test yourself?

Try a timed practice session using only Agentic Architecture and Orchestration questions.