Domain 1 – Questions

Q1. A support agent must never issue credits above $50 without human sign-off. Where does this rule live? A) The system prompt B) A deterministic harness gate with an HITL approval queue C) A few-shot example showing refusal D) A CLAUDE.md instruction

# Offline teaching simulation: no payment or shipment is performed.
# Production must make effect recording atomic with the operation, or use
# the provider's idempotency support and reconcile uncertain outcomes.
ledger = {}

def propose(operation_id, amount, approved=False):
    if operation_id in ledger:
        return ledger[operation_id]
    if amount > 50 and not approved:
        return {"status": "pending_approval"}
    result = {"status": "completed", "operation_id": operation_id}
    ledger[operation_id] = result
    return result

print(propose("credit-104", 75))
print(propose("credit-104", 75, approved=True))
print(propose("credit-104", 75, approved=True))

Q2. A pipeline summarizes a document, then extracts entities from the summary, then formats a report. The steps never change. The most appropriate architecture is: A) A single agent with three tools B) Prompt chaining workflow C) Evaluator–optimizer D) Orchestrator–workers

Q3. Your research system must scan 40 sources in parallel and synthesize findings. Choose: A) Orchestrator–workers with subagents returning summaries B) 40 parallel calls merged by string concatenation C) One agent looping 40 times D) Evaluator–optimizer

Q4. An agent's response has stop_reason: "max_tokens" and the JSON parses with fields missing. Root cause? A) Truncated output parsed as complete B) Model hallucination C) Schema too strict D) Temperature too high

{
  "id": "msg_demo_2",
  "type": "message",
  "role": "assistant",
  "model": "claude-sonnet-4-6",
  "content": [
    {
      "type": "text",
      "text": "{\"invoice_number\": \"INV-104\", \"total_cents\":"
    }
  ],
  "stop_reason": "max_tokens",
  "stop_sequence": null,
  "usage": {
    "input_tokens": 180,
    "output_tokens": 35,
    "cache_creation_input_tokens": 0,
    "cache_read_input_tokens": 0
  }
}

Q5. Which problem benefits most from semantic evaluation, such as an independently evaluated model judge plus human calibration? A) Rate limiting B) Tool timeout C) JSON schema violations D) Subtle factual/quality drift in generated summaries

Q6. The agent occasionally re-executes a refund after a network retry. Fix: A) Idempotency keys + effects ledger in the tool layer B) Lower temperature C) Longer timeout D) Prompt: "never refund twice"

# Offline teaching simulation: no payment or shipment is performed.
# Production must make effect recording atomic with the operation, or use
# the provider's idempotency support and reconcile uncertain outcomes.
ledger = {}

def propose(operation_id, amount, approved=False):
    if operation_id in ledger:
        return ledger[operation_id]
    if amount > 50 and not approved:
        return {"status": "pending_approval"}
    result = {"status": "completed", "operation_id": operation_id}
    ledger[operation_id] = result
    return result

print(propose("credit-104", 75))
print(propose("credit-104", 75, approved=True))
print(propose("credit-104", 75, approved=True))

Q7. When is a single-agent loop preferable to multi-agent? A) When subagents are unavailable B) When latency doesn't matter C) When the task fits one context window and one tool set D) Never at scale

Q8. A long-running provisioning agent dies mid-run after step 7 of 12. The architecture should have: A) Used a bigger model B) Emailed an admin C) Retried the whole run D) Checkpointed state per step and resumed at 8, replaying nothing with side effects

{
  "job_id": "job-104",
  "completed_steps": [
    1,
    2,
    3,
    4,
    5,
    6,
    7
  ],
  "next_step": 8,
  "effects": {
    "shipment-104": {
      "status": "confirmed",
      "provider_reference": "ship_demo_104"
    }
  },
  "uncertain_operations": []
}

Q31. In a production agent loop, the model emits a tool_use block for create_replacement with JSON arguments, and the tool has a real side effect. Which statement correctly assigns the schema-validation work that must happen before the shipment is created? A) The model validates the arguments against input_schema before the tool runs B) The Claude API executes the tool once the arguments match input_schema C) The harness validates the arguments against input_schema before the tool runs D) input_schema is enforced end-to-end by the API, so no validation step exists inside the loop

{
  "model": "claude-sonnet-4-6",
  "max_tokens": 1024,
  "system": "You help customers check order status. Use get_order for order facts. Never invent a status.",
  "tools": [
    {
      "name": "get_order",
      "description": "Read the status of an order the signed-in customer may access.",
      "input_schema": {
        "type": "object",
        "properties": {
          "order_id": {
            "type": "string",
            "description": "The order identifier, for example O-104."
          }
        },
        "required": [
          "order_id"
        ],
        "additionalProperties": false
      },
      "strict": true
    }
  ],
  "tool_choice": {
    "type": "auto"
  },
  "messages": [
    {
      "role": "user",
      "content": [
        {
          "type": "text",
          "text": "Where is order O-104?"
        }
      ]
    }
  ],
  "stream": false
}

{
  "id": "msg_demo_1",
  "type": "message",
  "role": "assistant",
  "model": "claude-sonnet-4-6",
  "content": [
    {
      "type": "tool_use",
      "id": "toolu_demo_1",
      "name": "get_order",
      "input": {
        "order_id": "O-104"
      }
    }
  ],
  "stop_reason": "tool_use",
  "stop_sequence": null,
  "usage": {
    "input_tokens": 180,
    "output_tokens": 35,
    "cache_creation_input_tokens": 0,
    "cache_read_input_tokens": 0
  }
}

{
  "model": "claude-sonnet-4-6",
  "max_tokens": 1024,
  "system": "You help customers check order status. Use get_order for order facts. Never invent a status.",
  "tools": [
    {
      "name": "get_order",
      "description": "Read the status of an order the signed-in customer may access.",
      "input_schema": {
        "type": "object",
        "properties": {
          "order_id": {
            "type": "string",
            "description": "The order identifier, for example O-104."
          }
        },
        "required": [
          "order_id"
        ],
        "additionalProperties": false
      },
      "strict": true
    }
  ],
  "tool_choice": {
    "type": "auto"
  },
  "messages": [
    {
      "role": "user",
      "content": [
        {
          "type": "text",
          "text": "Where is order O-104?"
        }
      ]
    },
    {
      "role": "assistant",
      "content": [
        {
          "type": "tool_use",
          "id": "toolu_demo_1",
          "name": "get_order",
          "input": {
            "order_id": "O-104"
          }
        }
      ]
    },
    {
      "role": "user",
      "content": [
        {
          "type": "tool_result",
          "tool_use_id": "toolu_demo_1",
          "content": "{\"order_id\": \"O-104\", \"status\": \"shipped\"}",
          "is_error": false
        }
      ]
    }
  ],
  "stream": false
}

{
  "id": "msg_demo_2",
  "type": "message",
  "role": "assistant",
  "model": "claude-sonnet-4-6",
  "content": [
    {
      "type": "text",
      "text": "Order O-104 has shipped."
    }
  ],
  "stop_reason": "end_turn",
  "stop_sequence": null,
  "usage": {
    "input_tokens": 180,
    "output_tokens": 35,
    "cache_creation_input_tokens": 0,
    "cache_read_input_tokens": 0
  }
}

Q32. In the support-agent walkthrough, turn 1's response carries "id": "toolu_01A" on the tool_use block, yet the tool definition you sent had no id field. Which statement is exactly right? A) The API generates a fresh id for every tool_use block; the returned tool_result must echo it as tool_use_id B) The harness generates a fresh id for every tool_use block; the returned tool_result must echo it as tool_use_id C) The id is declared in the tool definition alongside name and input_schema, once per tool D) Ids are optional correlation hints, required only when one response carries several tool requests

{
  "model": "claude-sonnet-4-6",
  "max_tokens": 1024,
  "system": "You help customers check order status. Use get_order for order facts. Never invent a status.",
  "tools": [
    {
      "name": "get_order",
      "description": "Read the status of an order the signed-in customer may access.",
      "input_schema": {
        "type": "object",
        "properties": {
          "order_id": {
            "type": "string",
            "description": "The order identifier, for example O-104."
          }
        },
        "required": [
          "order_id"
        ],
        "additionalProperties": false
      },
      "strict": true
    }
  ],
  "tool_choice": {
    "type": "auto"
  },
  "messages": [
    {
      "role": "user",
      "content": [
        {
          "type": "text",
          "text": "Where is order O-104?"
        }
      ]
    }
  ],
  "stream": false
}

{
  "id": "msg_demo_1",
  "type": "message",
  "role": "assistant",
  "model": "claude-sonnet-4-6",
  "content": [
    {
      "type": "tool_use",
      "id": "toolu_demo_1",
      "name": "get_order",
      "input": {
        "order_id": "O-104"
      }
    }
  ],
  "stop_reason": "tool_use",
  "stop_sequence": null,
  "usage": {
    "input_tokens": 180,
    "output_tokens": 35,
    "cache_creation_input_tokens": 0,
    "cache_read_input_tokens": 0
  }
}

{
  "model": "claude-sonnet-4-6",
  "max_tokens": 1024,
  "system": "You help customers check order status. Use get_order for order facts. Never invent a status.",
  "tools": [
    {
      "name": "get_order",
      "description": "Read the status of an order the signed-in customer may access.",
      "input_schema": {
        "type": "object",
        "properties": {
          "order_id": {
            "type": "string",
            "description": "The order identifier, for example O-104."
          }
        },
        "required": [
          "order_id"
        ],
        "additionalProperties": false
      },
      "strict": true
    }
  ],
  "tool_choice": {
    "type": "auto"
  },
  "messages": [
    {
      "role": "user",
      "content": [
        {
          "type": "text",
          "text": "Where is order O-104?"
        }
      ]
    },
    {
      "role": "assistant",
      "content": [
        {
          "type": "tool_use",
          "id": "toolu_demo_1",
          "name": "get_order",
          "input": {
            "order_id": "O-104"
          }
        }
      ]
    },
    {
      "role": "user",
      "content": [
        {
          "type": "tool_result",
          "tool_use_id": "toolu_demo_1",
          "content": "{\"order_id\": \"O-104\", \"status\": \"shipped\"}",
          "is_error": false
        }
      ]
    }
  ],
  "stream": false
}

{
  "id": "msg_demo_2",
  "type": "message",
  "role": "assistant",
  "model": "claude-sonnet-4-6",
  "content": [
    {
      "type": "text",
      "text": "Order O-104 has shipped."
    }
  ],
  "stop_reason": "end_turn",
  "stop_sequence": null,
  "usage": {
    "input_tokens": 180,
    "output_tokens": 35,
    "cache_creation_input_tokens": 0,
    "cache_read_input_tokens": 0
  }
}

Q33. A team must process vendor invoices nightly: classify the document type, extract fields, then validate totals — the same three steps in the same order, every invoice. All four designs below would produce correct output. Which should the architect choose? A) A single agent loop with a tight toolset covering all three steps B) Orchestrator–workers with one specialized worker per step C) An evaluator-optimizer loop that critiques extractions until the totals validate D) A prompt-chaining workflow with programmatic checks between the fixed steps

"""Offline Python 3.11+ demo: fixed workflow, bounded concurrent documents.
No API calls or real PDFs. Async sleeps simulate network waits, not model work.
SQLite records outcomes; the in-memory queue is NOT a durable production queue.
"""
import asyncio
import sqlite3
import tempfile
from pathlib import Path


async def classify(document_id):
    await asyncio.sleep(0.002)  # Stand-in for an awaited I/O or model request.
    return "invoice"


async def extract(document_id, document_type):
    assert document_type == "invoice"  # This stage requires classification first.
    await asyncio.sleep(0.002)
    # One bad invoice demonstrates per-document failure isolation.
    return {"line_totals_cents": [1000, 250],
            "total_cents": 999 if document_id == 7 else 1250}


def validate(fields):
    # Simplified invoice: no taxes/discounts. Real rules must account for those.
    if sum(fields["line_totals_cents"]) != fields["total_cents"]:
        raise ValueError("Invoice total does not match its line totals")


async def process_document(document_id):
    # Fixed order WITHIN one document; no LLM chooses these stages.
    document_type = await classify(document_id)
    fields = await extract(document_id, document_type)
    validate(fields)
    return fields


async def run(database, document_count=100, worker_count=4):
    if worker_count < 1 or document_count < 0:
        raise ValueError("Invalid worker/document count")
    db = sqlite3.connect(database)
    db.execute("CREATE TABLE IF NOT EXISTS outcomes "
               "(document_id INTEGER PRIMARY KEY, status TEXT, detail TEXT)")
    db.commit()
    queue = asyncio.Queue(maxsize=worker_count * 2)
    active = 0
    peak_active = 0

    async def produce():
        # Lazy IDs: no list of a million PDFs or a million asyncio tasks.
        for document_id in range(document_count):
            await queue.put(document_id)  # Waits if bounded queue is full.
        for _ in range(worker_count):
            await queue.put(None)  # One shutdown marker per consumer.

    async def consume():
        nonlocal active, peak_active
        while True:
            document_id = await queue.get()
            try:
                if document_id is None:
                    return
                active += 1
                peak_active = max(peak_active, active)
                try:
                    fields = await process_document(document_id)
                    status, detail = "completed", str(fields["total_cents"])
                except Exception as error:
                    # Record failure of this document, not failure of all workers.
                    status, detail = "failed", str(error)
                finally:
                    active -= 1
                # Small synchronous writes are sufficient for this demo.
                # Use suitable pooled/async persistence in a production service.
                with db:
                    db.execute("INSERT OR REPLACE INTO outcomes VALUES (?, ?, ?)",
                               (document_id, status, detail))
            finally:
                queue.task_done()

    try:
        # Fixed task count regardless of input size. TaskGroup cancels sibling
        # tasks on infrastructure failure instead of leaving a blocked producer.
        async with asyncio.TaskGroup() as group:
            group.create_task(produce())
            for _ in range(worker_count):
                group.create_task(consume())
        counts = dict(db.execute("SELECT status, COUNT(*) FROM outcomes GROUP BY status"))
        return counts, peak_active
    finally:
        db.close()


if __name__ == "__main__":
    with tempfile.TemporaryDirectory() as folder:
        counts, peak = asyncio.run(run(str(Path(folder) / "jobs.sqlite")))
        assert counts == {"completed": 99, "failed": 1}
        assert 1 < peak <= 4
        print(f"{counts}; peak concurrent documents: {peak}")

Q34. A PM asks for a positioning memo comparing 12 competitors' pricing pages; each fetched page is roughly 12K tokens of HTML. Any of these designs would eventually finish. Which is the Anthropic-doctrine best? A) One agent loop that fetches sequentially, with aggressive compaction of the growing messages array B) Orchestrator–workers: a coordinator plans, each worker researches one competitor in a clean scoped context and returns a compressed structured summary C) A prompt chain stepping through the competitors one at a time in a single conversation D) An evaluator-optimizer pass that critiques one combined research dump until it reads well

Q35. Call 1 of an agent loop returns stop_reason tool_use, and the harness has executed the tool. Remembering that the Claude API is stateless, in what order does the messages array change before call 2? A) Append the assistant's response verbatim (tool_use block included), then append the tool_result inside a user-role message — both at the end of the array B) Append the tool_result first so the model reads the freshest data last, then the assistant response C) Prepend both new turns so the model encounters them before the older history D) Append only the tool_result; re-sending the model its own words is redundant

{
  "model": "claude-sonnet-4-6",
  "max_tokens": 1024,
  "system": "You help customers check order status. Use get_order for order facts. Never invent a status.",
  "tools": [
    {
      "name": "get_order",
      "description": "Read the status of an order the signed-in customer may access.",
      "input_schema": {
        "type": "object",
        "properties": {
          "order_id": {
            "type": "string",
            "description": "The order identifier, for example O-104."
          }
        },
        "required": [
          "order_id"
        ],
        "additionalProperties": false
      },
      "strict": true
    }
  ],
  "tool_choice": {
    "type": "auto"
  },
  "messages": [
    {
      "role": "user",
      "content": [
        {
          "type": "text",
          "text": "Where is order O-104?"
        }
      ]
    }
  ],
  "stream": false
}

{
  "id": "msg_demo_1",
  "type": "message",
  "role": "assistant",
  "model": "claude-sonnet-4-6",
  "content": [
    {
      "type": "tool_use",
      "id": "toolu_demo_1",
      "name": "get_order",
      "input": {
        "order_id": "O-104"
      }
    }
  ],
  "stop_reason": "tool_use",
  "stop_sequence": null,
  "usage": {
    "input_tokens": 180,
    "output_tokens": 35,
    "cache_creation_input_tokens": 0,
    "cache_read_input_tokens": 0
  }
}

{
  "model": "claude-sonnet-4-6",
  "max_tokens": 1024,
  "system": "You help customers check order status. Use get_order for order facts. Never invent a status.",
  "tools": [
    {
      "name": "get_order",
      "description": "Read the status of an order the signed-in customer may access.",
      "input_schema": {
        "type": "object",
        "properties": {
          "order_id": {
            "type": "string",
            "description": "The order identifier, for example O-104."
          }
        },
        "required": [
          "order_id"
        ],
        "additionalProperties": false
      },
      "strict": true
    }
  ],
  "tool_choice": {
    "type": "auto"
  },
  "messages": [
    {
      "role": "user",
      "content": [
        {
          "type": "text",
          "text": "Where is order O-104?"
        }
      ]
    },
    {
      "role": "assistant",
      "content": [
        {
          "type": "tool_use",
          "id": "toolu_demo_1",
          "name": "get_order",
          "input": {
            "order_id": "O-104"
          }
        }
      ]
    },
    {
      "role": "user",
      "content": [
        {
          "type": "tool_result",
          "tool_use_id": "toolu_demo_1",
          "content": "{\"order_id\": \"O-104\", \"status\": \"shipped\"}",
          "is_error": false
        }
      ]
    }
  ],
  "stream": false
}

{
  "id": "msg_demo_2",
  "type": "message",
  "role": "assistant",
  "model": "claude-sonnet-4-6",
  "content": [
    {
      "type": "text",
      "text": "Order O-104 has shipped."
    }
  ],
  "stop_reason": "end_turn",
  "stop_sequence": null,
  "usage": {
    "input_tokens": 180,
    "output_tokens": 35,
    "cache_creation_input_tokens": 0,
    "cache_read_input_tokens": 0
  }
}

Q36. A support agent's HITL policy auto-approves replacements under $100. Mid-run, the model emits create_replacement for a $600 order. What happens first? A) The harness executes the tool under an idempotency key, then routes the receipt to a human for retroactive sign-off B) The model is re-prompted to ask the customer for permission before continuing C) The tool executes normally and the audit trail flags the run for post-hoc review D) The gate fires before execution: the run parks, a human receives the handoff packet, and nothing has executed

{
  "operation_id": "replacement-104",
  "action": "create_replacement_shipment",
  "status": "pending_approval",
  "executed": false,
  "requested_by": "customer_demo",
  "required_approver_role": "support_manager"
}

Q37. Decode stop_reason: max_tokens — exactly. A) The messages array outgrew the context window, so the API rejected the request before any generation B) The model finished its turn comfortably under the output ceiling C) Generation halted at the output-token ceiling you set for this call — the response is incomplete and must never be parsed as complete D) A custom stop string you configured was matched mid-generation

{
  "id": "msg_demo_2",
  "type": "message",
  "role": "assistant",
  "model": "claude-sonnet-4-6",
  "content": [
    {
      "type": "text",
      "text": "{\"invoice_number\": \"INV-104\", \"total_cents\":"
    }
  ],
  "stop_reason": "max_tokens",
  "stop_sequence": null,
  "usage": {
    "input_tokens": 180,
    "output_tokens": 35,
    "cache_creation_input_tokens": 0,
    "cache_read_input_tokens": 0
  }
}

Q38. Anthropic's Building Effective Agents draws one line between "workflow" and "agent." Which option decodes the official distinction exactly? A) A workflow is any system where an LLM calls tools; an agent is one that additionally loops B) A workflow orchestrates LLM calls through predefined code paths; an agent dynamically directs its own process and tool usage C) A workflow dynamically directs its own process; an agent follows predefined code paths D) A workflow contains no model calls; an agent is any model call wrapped in a harness

Q39. A transient network timeout hit mid-run, the harness retried the turn, and the customer received two replacement shipments for one lost order. Root cause? A) Missing checkpointing — the agent restarted from scratch instead of resuming its saved state B) The HITL approval threshold was set too high to catch the second shipment C) The turn budget was generous enough to allow a second attempt D) Missing idempotency — the retry re-executed the side effect instead of consulting an effects ledger keyed on the action

# Offline teaching simulation: no payment or shipment is performed.
# Production must make effect recording atomic with the operation, or use
# the provider's idempotency support and reconcile uncertain outcomes.
ledger = {}

def propose(operation_id, amount, approved=False):
    if operation_id in ledger:
        return ledger[operation_id]
    if amount > 50 and not approved:
        return {"status": "pending_approval"}
    result = {"status": "completed", "operation_id": operation_id}
    ledger[operation_id] = result
    return result

print(propose("credit-104", 75))
print(propose("credit-104", 75, approved=True))
print(propose("credit-104", 75, approved=True))

Q40. An extraction sometimes fails parsing. Logs for each failed response show stop_reason max_tokens, but the harness accepts responses without checking that field. Root cause? A) The harness parses responses without branching on stop_reason, so max_tokens truncations are treated as complete output B) The model intermittently ignores the input_schema on its tool arguments C) A guardrail is rejecting valid JSON on alternating runs D) Missing checkpointing corrupts the messages array between turns

{
  "id": "msg_demo_2",
  "type": "message",
  "role": "assistant",
  "model": "claude-sonnet-4-6",
  "content": [
    {
      "type": "text",
      "text": "{\"invoice_number\": \"INV-104\", \"total_cents\":"
    }
  ],
  "stop_reason": "max_tokens",
  "stop_sequence": null,
  "usage": {
    "input_tokens": 180,
    "output_tokens": 35,
    "cache_creation_input_tokens": 0,
    "cache_read_input_tokens": 0
  }
}

Q220. A freight company's coordinator asks a subagent to normalise 40,000 shipping addresses. The delegation prompt is eleven numbered steps (split on commas, uppercase the third field, pad postcodes to five digits, and so on). Partway through, the subagent meets a new region whose addresses contain no commas, keeps executing step two anyway, and reports success on thousands of mangled rows. Which diagnosis is exactly right? A) The subagent had too many tools available, which distracted it from the address-parsing steps it was supposed to follow in order. B) The subagent ran out of output budget while reasoning about the new format, so it fell back to the literal steps it had been given. C) The steps were sound; the prompt only needed a rule telling the subagent to halt and ask the coordinator whenever input deviates from the script. D) The prompt specified how to work but never what a correct result looks like, so when the data broke the script the subagent had no criterion to notice failure or adapt toward.

Q221. A documentation platform's coordinator receives two jobs at once: correct a misspelled word in one README heading, and audit 400 API reference pages for broken cross-links. The coordinator already has the README open. Which assignment keeps coordination cost lowest while keeping the coordinator's own context clean? A) Two subagents, one per job, so the coordinator stays a pure router and never edits files itself. B) A subagent fixes the heading, while the coordinator audits the pages because link checking needs the global view only it holds. C) The coordinator fixes the heading itself and hands the 400-page audit to one subagent that returns only the list of broken links. D) The coordinator does both, reading all 400 pages into its own context so it has a complete picture for future requests.

Q222. A market-intelligence system is asked to profile the payment methods used by consumers across Southeast Asia. The final report covers credit cards and bank transfers in depth but never mentions e-wallets, buy-now-pay-later or cash on delivery. Reviewers agree each worker's section is thorough and well sourced. Which single piece of evidence would most directly confirm where the gap originated? A) The synthesis worker's prompt, to check whether it was told to flag categories missing from its inputs. B) The retrieval index, to verify whether documents about e-wallets and buy-now-pay-later exist in the corpus at all. C) The coordinator's delegation record showing the list of subtopics it assigned before any worker started. D) The search worker's query log, to see whether its queries were phrased too narrowly to surface wallet providers.

Q223. A support agent's loop ends when the assistant's text contains the sentinel "FINAL ANSWER:". Some tickets end mid-task because the agent quotes a customer email that happens to contain that phrase; others grind on until the 25-turn safety cap even though the work finished earlier. Which statement about the loop's exit condition is exactly right? A) A rarer sentinel such as a random token would fix both failures, because customers could never type it by accident. B) Every response already carries a stop_reason that separates wanting a tool (tool_use) from being finished (end_turn), so the loop should branch on that field rather than on text. C) Keep the sentinel but normalise case and require it at the very end of the message, so quoted text cannot trigger it. D) The 25-turn cap is the real defect; raising it lets long tickets reach the sentinel before the loop gives up.

Q224. A travel-planning coordinator runs a flight agent and then a hotel agent. The flight agent finds that the only affordable flight lands a day later than the traveller asked for and returns that itinerary. The hotel agent then books rooms starting on the originally requested date, leaving a paid night unused. The two agents never exchange messages. Which change fixes this at the right layer? A) Add a shared table that both agents poll while they work, so each can see the other's latest decisions. B) Run the hotel agent first, so the booked dates constrain which flights the flight agent is allowed to choose. C) The coordinator puts the flight agent's confirmed arrival date and time into the hotel agent's delegation prompt. D) Give the hotel agent read access to the flight agent's working log so it can find the arrival date on its own.

{
 "task": "Book a hotel near the conference venue",
 "constraints": {
  "check_in": "2026-11-04",
  "check_out": "2026-11-07",
  "max_nightly_rate_usd": 220
 },
 "from_flight_agent": {
  "arrival_local": "2026-11-04T21:40",
  "airport": "SIN",
  "note": "Only affordable option lands one day after the requested date"
 },
 "return_format": "hotel name, confirmation id, total cost"
}

Q225. A hospital's procurement officer wants three infusion-pump vendors compared on recall history, five-year total cost of ownership and nurse usability, with every criterion measured the same way for all three vendors so the committee can read the table across. Which decomposition is MOST likely to produce a comparison that cannot be read side by side? A) One worker per criterion, each covering all three vendors, followed by a synthesis step. B) One worker per criterion, with the coordinator fixing the metric definition in each brief, then synthesis. C) One worker per vendor, each researching all three criteria for its own vendor, merged at the end. D) A single worker researching every vendor and criterion in one pass, filling a supplied comparison template.

Q226. A platform team is choosing an orchestration style for four upcoming jobs. Which TWO jobs are better served by a fixed prompt chain than by dynamic adaptive decomposition? (Select TWO.) A) Migrating an undocumented internal library whose callers and hidden dependencies have not yet been mapped. B) A weekly compliance check that runs the same five named checks on every pull request in a fixed order. C) Investigating why a mobile app's crash rate doubled after an unknown combination of recent releases. D) Nightly processing of supplier invoices: extract fields, validate totals, post to the ledger, the same three steps every night.

Q227. An analytics team inherits a data warehouse of 900 tables with no lineage documentation, and nobody knows which tables actually feed the revenue dashboards. An agent is asked to produce useful documentation for the warehouse. What should the agent's first phase be? A) Trace lineage backward from the dashboards' queries to find which tables matter, then set documentation depth according to what that map reveals. B) Document every table alphabetically with one uniform template so coverage is even and progress is easy to track. C) Write the complete documentation outline for all 900 tables in a single pass before looking at any query history. D) Split the 900 tables evenly across ten parallel workers, each documenting its 90 tables in full.

Q228. A law firm's intake assistant has five specialists: conflict checking, jurisdiction research, fee estimation, document drafting and translation. Its coordinator invokes all five for every inquiry, including "What are your office hours?", and the partners complain about cost and slow replies. Where should the fix live? A) In the coordinator: assess each inquiry and dispatch only the specialists it actually needs. B) In the front end: add a separate FAQ bot so simple questions never reach the multi-agent system. C) In the specialists' configuration: lower each one's output budget so unnecessary runs finish faster. D) In each specialist: add an early check that returns "not applicable" when an inquiry is outside its area.

Q229. A security analyst has spent a long session triaging an intrusion and building a detailed attack timeline. She now wants to evaluate two containment plans (isolate the affected subnet, or rotate every credential and keep services running), each reasoned from the same full timeline, without either plan's reasoning leaking into the other. What should she do? A) Export the timeline to a notes file and open two new sessions that each read the file. B) Resume the session, evaluate the subnet plan, then clear the conversation and evaluate the credential plan. C) Fork the session from the finished timeline twice and evaluate one containment plan in each branch. D) Ask the agent to evaluate both plans side by side in a single reply so neither one is favoured.

# baseline session id comes from the triage run
claude --resume 7c1e-triage --fork-session -p "Evaluate containment plan one: isolate the affected subnet."
claude --resume 7c1e-triage --fork-session -p "Evaluate containment plan two: rotate all credentials, keep services running."

Q230. During a long session tuning a pricing service, operations roll back a deployment and several configuration files on disk change. The agent keeps quoting the old values it read an hour ago. A teammate says, "Just tell it to reread the changed files." Why is that alone unlikely to fully fix the problem? A) The context window is already full, so any new file contents are silently dropped before the model sees them. B) Rereading works fully; the agent simply needs extended thinking enabled to notice that the values changed. C) The earlier reads stay in the conversation beside the new ones, so the agent can still anchor on the outdated values in later reasoning. D) File tools cache results for the lifetime of a session, so a reread returns the same stale content.

Q231. A due-diligence system produces a memo on an acquisition target. The coordinator's review finds that one revenue figure has no source and the question about pending litigation was never answered; everything else is solid. Which next step keeps the good work and closes the holes? A) Ask the synthesis worker to supply the revenue source and litigation status from what it already knows. B) Send narrowly scoped follow-up tasks for the unsourced revenue figure and the litigation question, then rerun synthesis with the new findings. C) Discard the memo and rerun every worker with a longer, more detailed brief. D) Mark the two gaps as unverified and deliver the memo, letting the client's analysts chase the missing evidence.

Q232. An insurance intake agent is meant only to collect and verify policy details, but it has eleven tools, including approve_payout, draft_denial_letter and score_fraud_risk. In testing it sometimes drafts denial letters during intake. A system-prompt warning has already been tried. Which fix removes the cause rather than the symptom? A) Give the intake agent only its collection and verification tools, and move payout, denial and fraud tools to the adjudication agent. B) Strengthen the system prompt with a bold rule that the intake agent must never use adjudication tools. C) Keep all eleven tools but add a hook that rejects adjudication tool calls coming from the intake agent. D) Rewrite the adjudication tools' descriptions to say they are only for use after intake is complete.

Q233. A release pipeline uses three generator subagents: one writes the iOS client, one the Android client, and one the shared API contract. After a run, Android sends timestamps as epoch milliseconds, iOS sends ISO strings, and the contract expects ISO strings. Each generator's output is internally consistent. Where should the consistency check live? A) In the coordinator's own planning turn, with extended thinking enabled so it can compare the three outputs itself. B) In a dedicated reviewer that receives all three outputs from the coordinator and checks only cross-component agreement. C) In each generator, by letting it browse the other generators' working directories while it runs. D) In each generator, re-prompted with an instruction to match the other platforms' formats before returning.

Q234. A database team's coordinator runs a migration-writer subagent and then a rollback-writer subagent for each ticket. Reviewers notice the rollback scripts reliably undo what each ticket describes, but miss extra changes the migration writer actually made, such as an index it added for performance. What explains the pattern? A) The tickets are too vague; more precise tickets would keep both scripts in agreement. B) The rollback writer lacks a database connection to inspect the live schema after the migration runs. C) The two writers run on different model tiers and therefore interpret the ticket differently. D) The rollback writer receives only the ticket, never the migration script the first writer produced.

Q235. An IT help-desk agent runs a fourteen-question diagnostic interview (operating system, network, recent updates, log excerpts) on every ticket, including "Please reset my password". Staff rate the assistant as exhausting, yet for real outages the full interview is what engineers need. Which change serves both kinds of ticket? A) Triage each ticket by type first and pick the interview depth from that type: none for a password reset, the full diagnostic for an outage. B) Shorten the wording of each of the fourteen questions so the interview is quicker to answer. C) Drop the interview and require staff to complete a detailed form before any ticket is accepted. D) Cap the interview at four questions for every ticket.

Q236. An agent must write a SQL query whose output matches a finance team's reference report. On each retry it writes a brand-new query from scratch, and after eight attempts the mismatch persists in different places each time. What input is the retry loop missing? A) A system-prompt reminder to fix the previous attempt rather than start over. B) A higher retry ceiling so the agent has more attempts to land on a matching query. C) A lower temperature so each fresh attempt is more deterministic. D) The previous query together with the specific rows where its output differed from the reference.

Q237. An e-commerce operations assistant spawns inventory, pricing and fraud specialists for every request. Asking "How many units of the blue kettle are in stock?" takes as long and costs as much as "Why did our margin drop last week?", which genuinely needs all three. Which statement about the redesign is exactly right? A) The cheapest fix is to keep all three specialists on every request but have them share one cached context. B) Because the margin investigation needs all three specialists, the stock lookup must also run them to keep output formats consistent. C) The coordinator should improvise a fresh architecture for each request, since no single policy can cover both kinds. D) The selection rule is designed once into the coordinator, and each request is assessed so the rule decides which specialists that request actually runs.

Q238. A localisation coordinator reviews four independent translation files (French, German, Japanese and Portuguese), delegating one per turn and waiting for each reviewer to finish before starting the next. Each review takes about 40 seconds, so the full pass takes nearly three minutes. What should the coordinator do differently in its output? A) Raise each reviewer's max_tokens so it can finish in a single turn. B) Emit all four review delegations as tool_use blocks in the same assistant response, so a runtime that executes them concurrently runs them together. C) Keep one delegation per turn but shorten each reviewer's prompt so it responds faster. D) Merge the four languages into one reviewer so there is only one handoff.

{
 "role": "assistant",
 "content": [
  {
   "type": "text",
   "text": "Reviewing all four locales in parallel."
  },
  {
   "type": "tool_use",
   "id": "toolu_fr",
   "name": "Agent",
   "input": {
    "description": "Review French strings",
    "prompt": "Review locales/fr.json against the glossary; return issues as a list."
   }
  },
  {
   "type": "tool_use",
   "id": "toolu_de",
   "name": "Agent",
   "input": {
    "description": "Review German strings",
    "prompt": "Review locales/de.json against the glossary; return issues as a list."
   }
  },
  {
   "type": "tool_use",
   "id": "toolu_ja",
   "name": "Agent",
   "input": {
    "description": "Review Japanese strings",
    "prompt": "Review locales/ja.json against the glossary; return issues as a list."
   }
  },
  {
   "type": "tool_use",
   "id": "toolu_pt",
   "name": "Agent",
   "input": {
    "description": "Review Portuguese strings",
    "prompt": "Review locales/pt.json against the glossary; return issues as a list."
   }
  }
 ]
}

Q239. A team asks an agent, in one instruction, to internationalise a 25-screen app: find every hard-coded string, replace each with a translation key, and reconcile duplicate keys across screens. The result is inconsistent: some screens are clean, others keep hard-coded text, and the same phrase gets different keys on different screens. Which explanation best accounts for this? A) The prompt lacked examples; two well-chosen examples in the single instruction would make every screen consistent. B) The response was truncated, so a larger max_tokens would have let the agent finish consistently. C) The model cannot edit more than a few files per request, so the work should be split only by file count. D) One instruction asked for three different jobs across 25 screens at once, so attention per job thinned; each stage needs its own focused pass.

Q240. A product analyst spent an hour in an agent session building a churn analysis of subscription cohorts. She now wants to test two pricing ideas, an annual-plan discount and a usage-based tier, each starting from that analysis, without either exploration influencing the other. Which statement about using a session fork for this is correct? A) A fork keeps only a compacted summary of the original session, trading detail for isolation. B) A fork is equivalent to resuming; both simply append new turns to the original session's history. C) A fork creates a new session whose history begins as a copy of the original at the fork point, so each branch keeps the full analysis and neither sees the other's later turns. D) A fork shares one live history, so turns in either branch appear in both and keep them in sync.

from claude_agent_sdk import query, ClaudeAgentOptions

async def explore(baseline_id, idea):
    opts = ClaudeAgentOptions(resume=baseline_id, fork_session=True)
    async for msg in query(prompt=f"Using the churn analysis so far, evaluate: {idea}", options=opts):
        print(msg)

# await explore(saved_id, 'annual-plan discount')
# await explore(saved_id, 'usage-based tier')

Q241. A pre-launch readiness review spawns legal, accessibility and performance reviewers in parallel. All three return successfully and no errors are logged, yet the final readiness report contains only accessibility findings. Which control would have caught this before the report went out? A) Before synthesis, the coordinator checks that it holds a result for every reviewer it dispatched and passes all of them into the synthesis step. B) Tell the synthesis step to write "no issues found" for any area without findings. C) Automatically retry any reviewer whose call returns an error. D) Raise each reviewer's turn limit so it has room to finish its analysis.

Q242. A compliance agent scans 60 vendor contracts for a nonstandard indemnity clause and runs with a 10-turn limit. In about half the runs it stops after roughly 35 contracts, missing later matches; in the rest it reaches all 60. No tool errors are logged. What is the root cause? A) Contracts after the 35th are longer, so the model stops reading them in detail. B) The system prompt does not list all 60 contract file names, so the model loses track of which contracts remain. C) The turn limit is set below what the task needs, so the loop is cut off mid-scan; completion should come from end_turn, with any cap kept as a generous safety ceiling. D) A rate limit silently drops tool calls after about 35 contracts.

Q243. A team configures an incident-postmortem orchestrator with the Agent SDK. Its system prompt says to hand timeline reconstruction and log analysis to the subagents defined in its configuration. Every run finishes in a single turn with the orchestrator writing a shallow postmortem itself; no subagent ever starts and no errors appear. Which configuration problem is MOST likely? A) The permission mode is set to accept edits, which disables all subagents. B) The delegation tool (named Agent in current SDK docs, Task in older material) is not among the tools available to the orchestrator, so it has nothing to call. C) The subagent definitions omit a model field, so they cannot start. D) The system prompt says "hand off" instead of naming each subagent's identifier.

Q244. An inventory-reconciliation agent's loop returns as soon as a response contains any text block. When the model writes "Let me check the warehouse count" and also requests a tool in the same response, the loop exits before the tool ever runs. Which rule should the loop follow instead? A) Return when the text mentions a final reconciled count; otherwise keep looping. B) If stop_reason is tool_use, run every requested tool, append the tool_result blocks in a user message and call again; if it is end_turn, return the answer. C) Return when the response contains any text; otherwise execute the tools. D) Run exactly five iterations and return whatever text the last response contains.

def run(client, model, messages, tools, execute):
    while True:
        resp = client.messages.create(model=model, max_tokens=2048, tools=tools, messages=messages)
        messages.append({"role": "assistant", "content": resp.content})
        if resp.stop_reason == "tool_use":
            results = [
                {"type": "tool_result", "tool_use_id": b.id, "content": execute(b.name, b.input)}
                for b in resp.content if b.type == "tool_use"
            ]
            messages.append({"role": "user", "content": results})
            continue
        if resp.stop_reason == "end_turn":
            return resp
        raise RuntimeError(f"unhandled stop_reason: {resp.stop_reason}")

import os
from typing import Annotated

import anthropic
from anthropic import beta_tool
from pydantic import Field

from app.repo import code_search  # your own module

client = anthropic.Anthropic()  # reads ANTHROPIC_API_KEY
MODEL = os.environ.get("CLAUDE_MODEL", "claude-sonnet-5")


@beta_tool(
    name="search_code",
    description="Search the repository and return matching paths with line numbers.",
)
def search_code(pattern: Annotated[str, Field(description="Text or a regular expression to find, e.g. legacyAuthenticate.")]) -> str:
    return code_search.grep(pattern)


def run(task: str):
    runner = client.beta.messages.tool_runner(
        model=MODEL, max_tokens=2048, tools=[search_code],
        messages=[{"role": "user", "content": task}],
        max_iterations=20,  # a safety ceiling, not the success signal
    )
    last = None
    for last in runner:  # one assistant message per turn; narration text does not stop it
        print(last.stop_reason, last.usage.output_tokens)
    if last is not None and last.stop_reason == "end_turn":
        return last
    raise RuntimeError(f"stopped without end_turn: {last and last.stop_reason}")

Q245. A property-valuation assistant asks a comparable-sales subagent (about 2.4 s) and then a zoning-rules subagent (about 2.1 s), one after the other, for each address. End-to-end latency is about 5 s, and the two lookups are independent. Which change lowers latency the most, and to roughly what? A) Request both subagents in the same coordinator response so they overlap, bringing latency down toward the slower lookup, around 2.5 to 3 s. B) Put a 1-second timeout on the zoning subagent so the sales subagent can start sooner. C) Switch the coordinator to a smaller, faster model, because its planning turns dominate the 5 seconds. D) Fold both lookups into the coordinator's own context to avoid the cost of spawning subagents.

Q246. A curriculum builder uses research subagents to gather material, then drafts a course outline in a single pass. On broad subjects such as "climate science for policymakers", some modules end up thin or empty, but the coordinator declares the outline finished anyway. Which coordination pattern most directly improves coverage? A) Have the final outline list thin modules in an appendix so readers know where to look elsewhere. B) Give each research subagent a larger output budget so it returns more material per call. C) Spawn twice as many research subagents at the start of every run. D) Have the coordinator check the draft against the intended coverage, send targeted research tasks for thin modules, and repeat until every module meets the bar.

Q247. A meal-planning service runs a nutrition subagent and an allergy subagent, then spawns a plan-writer subagent. Both analysis subagents succeed, but the meal plans reflect only the nutrition findings, and some include foods the allergy check flagged. Logs show the plan-writer's prompt contained the nutrition output alone. Which statement is exactly right? A) Subagents automatically inherit the coordinator's full history, so the allergy output must have been truncated by the plan writer. B) The plan writer knows only what its delegation prompt contains or explicitly references, so the allergy findings never reached it. C) The allergy results were returned as structured JSON, which subagent prompts cannot accept. D) Subagents can read each other's results through a shared session store unless isolation is turned off.

Q248. A policy institute asks its research system about the consequences of a four-day work week. The coordinator's plan lists four subtasks, all about employee outcomes (productivity, burnout, retention, commuting), and the report never covers employer costs, customer-service coverage or effects on public services. Which change prevents this class of failure? A) Have the coordinator check its subtask list against the full scope of the question, adding missing dimensions before any delegation. B) Instruct search workers to broaden their queries beyond the subtopic they were assigned. C) Tell the synthesis worker to add sections for obvious omissions from its own general knowledge. D) Loosen the analysis worker's relevance filter so more borderline sources pass through.

Q249. A medical-billing pipeline runs three steps: identify the claim type, assign billing codes, then check that codes agree with the diagnosis. Dental claims reach 71% accuracy while outpatient claims reach 96%. An engineering lead proposes merging all three steps into one prompt to cut cost by more than half. What evidence would need to exist before the merge is acceptable? A) A pilot running the merged prompt on outpatient claims only, since they are already accurate. B) An evaluation on labelled claims showing the merged prompt matches the pipeline's accuracy for each claim type, dental included, and still catches code-diagnosis mismatches. C) A latency benchmark showing the merged prompt is faster on average. D) Sign-off from the product owner accepting somewhat lower accuracy on dental claims.