Agents and Workflows

A migration assistant is built as an agent with a set of tools. Some runs finish after two tool calls and others after fifteen, and the team wants the loop condition expressed in application code rather than guessed from the assistant's output text. What correctly decides whether the agentic loop should run another turn?

• AThe application counts the tool calls made so far and ends the run once that count reaches a configured ceiling for the migration task
• BThe application inspects the stop reason on each response and continues only while the model has asked to use a tool, executing it and returning the resultcheck_circle Correct
• CThe application matches the assistant text against a completion phrase agreed in the system prompt, and ends the run when that phrase appears
• DThe application ends the run when a response arrives whose output token usage is well below the configured limit, indicating nothing further was produced

Why A is wrong: Tempting because a ceiling is a sensible safety limit, but a cap protects against a runaway run rather than signalling that the model has finished its work.

Why B is correct: Correct because the stop reason is the structured signal describing why generation halted, so it distinguishes a pending tool call from a finished answer without parsing prose.

Why C is wrong: Tempting because instructing a closing phrase seems deterministic, but it depends on the model reproducing wording exactly, which makes termination a prompt behaviour rather than a protocol fact.

Why D is wrong: Tempting because a short reply often does mean completion, but a brief response can still carry a tool request, so usage size cannot decide termination.

A finance team processes invoices through five fixed steps that run in the same order for every invoice: extract fields, validate totals, classify the cost centre, check the amount against an approval threshold, and write a record to the ledger. The steps never vary, the team must be able to point at which step failed for any given invoice, and an audit requirement says the sequence of steps must be reproducible six months later. Which architecture fits these constraints best?

• AAn agent given the five steps in its system prompt and a set of tools, left to decide the order of tool calls for each invoice as it reasons through the document.
• BA deterministic workflow that calls Claude at the individual steps that need language understanding, with the ordering, branching and error handling expressed in application code.check_circle Correct
• CA manager agent that delegates each of the five steps to a dedicated subagent and merges their results once every subagent has reported back on the invoice.
• DA single model call that receives the whole invoice and the five step descriptions and returns the ledger record, with a validation pass over the returned structure.

Why A is wrong: Tempting because a model that can call the same five tools looks equivalent and needs less orchestration code, but the order becomes a model decision that can differ per invoice, which defeats both the per-step failure attribution and the reproducibility requirement.

Why B is correct: Correct: the path is fixed and known in advance, so the control flow belongs in code, and each model call sits at a named step whose input, output and failure are individually observable and repeatable.

Why C is wrong: Tempting because one subagent per step maps neatly onto the five steps, but delegation buys context isolation for open-ended exploration, and here it adds a coordination layer and a nondeterministic ordering decision that the fixed sequence does not earn.

Why D is wrong: Tempting because it is the cheapest thing to build and structured output does catch malformed results, but collapsing five steps into one call leaves nothing to attribute a failure to, and validating the final shape says nothing about which step went wrong.

A research assistant must answer one question by reading across four unrelated internal document stores. A single-agent build currently reads all four in turn, and by the fourth store the context window is dominated by raw document text, with a measured rise in answers that contradict the earlier sources. Each store can be searched independently, and the final answer must reconcile all four. Which change addresses the measured failure?

• AIncrease the number of search results retrieved per store so the assistant has more supporting passages available before it composes the reconciled final answer.
• BInstruct the assistant in its system prompt to re-read the earlier sources carefully and to avoid contradicting them when it writes the final reconciled answer.
• CGive a coordinator agent four subagents, one per store, each searching in its own context and returning a condensed finding, and have the coordinator reconcile the four findings.check_circle Correct
• DKeep the single agent and compact the conversation automatically whenever the context approaches its limit, so older document text is summarised as the search proceeds.

Why A is wrong: Tempting because thin retrieval is a common cause of weak answers, but the trace shows the context is already saturated with raw text, so adding passages makes the crowding that produced the contradictions worse rather than better.

Why B is wrong: Tempting because the failure looks like carelessness that wording could correct, but an instruction cannot restore detail that has been crowded out of the window, and prompt wording is advice rather than a structural fix to context pressure.

Why C is correct: Correct: the searches are independent, so isolating each one in its own context keeps raw document text out of the coordinator's window and leaves it holding only the four condensed findings it needs to reconcile.

Why D is wrong: Tempting because compaction genuinely relieves context pressure in long-running sessions, but it summarises after the crowding has occurred and does so lossily, whereas the independent searches here can be kept out of the main window in the first place.

A support agent handles the same customer several times a year in separate sessions. Advisers require it to recall that customer's stated accessibility preferences and past resolutions across those sessions, while each new session must still start well inside its latency budget. Transcripts run to thousands of turns per customer per year. Which memory design meets both requirements?

• ALoad the customer's full prior transcripts into the system prompt at the start of every session, so the agent has the complete history available before the first adviser question arrives.
• BRely on a long context window and keep one continuous conversation open per customer for the whole year, so nothing has to be written down or retrieved between the individual sessions.
• CWrite durable facts such as preferences and resolutions to an external store as they are confirmed, and load only the entries relevant to the current session through a retrieval tool.check_circle Correct
• DSummarise each session into a paragraph at the end and append every paragraph to a growing block that is placed into the system prompt in full at the start of the next session.

Why A is wrong: Tempting because full history guarantees nothing is missed, but thousands of turns cost time to load and process at session start, which is the latency the requirement explicitly bounds.

Why B is wrong: Tempting because it avoids building a store at all, but a year-long conversation grows past any window and makes recall depend on an ever-lengthening transcript rather than on durable facts.

Why C is correct: Correct, because agent memory held outside the context window persists across sessions, and retrieving only the relevant entries keeps session start small enough to sit inside the stated latency budget.

Why D is wrong: Tempting because summarising does shrink the raw transcript, but an append-only block still grows without bound across a year and offers no way to load only what the current session needs.