Since your exam is in English, everything below is written in English — the same language you'll see on test day. Two hover mechanisms give you Vietnamese meaning without switching languages:
Score weight per domain (based on the 77‑question Study Guide):
Strategy: study D1 first (highest weight and most questions — 22), then D2+D3+D4 (similar weight each), then D5 last — it only has 3 questions in the bank but still counts for 15% of the real exam, so 3 focused principles are enough.
Roughly 3–4 hours per phase. Use the three quiz files you already have for practice after reading each phase's theory.
🗺️ Big picture, from the source — this is a faithful redraw of Anthropic's own published multi-agent Research architecture, not something invented from the quiz questions. Component names (LeadResearcher, Subagents, Memory, CitationAgent) are Anthropic's actual names. Click any number to jump to that principle below.
"Our Research system uses a multi-agent architecture with an orchestrator-worker pattern, where a lead agent coordinates the process while delegating to specialized subagents that operate in parallel." — Anthropic Engineering, "How we built our multi-agent research system," Jun 2025
Notice: only LeadResearcher talks to Subagents, Memory, and CitationAgent — subagents never call each other directly, and none of them spawn further children. That flat, hub‑and‑spoke shape is exactly what principles 8 and 19 describe.
Read it yourself: How we built our multi-agent research system ↗ · Building Effective Agents ↗
When the failure is a missing-context problem (e.g., a caller in an unchanged file isn't included in a static prompt), the fix is to turn the task into an agentic one where the model can read files and search the codebase via tools — not add chain-of-thought instructions or expand the prompt with static analysis.
Use Glob and Grep to map the codebase structure, prioritize high-impact and heavily-coupled areas, create a plan, and revise it as new dependencies are discovered — don't read every file exhaustively, split effort evenly by directory, or proceed arbitrarily.
This structure is most valuable for open-ended, judgment-heavy requests (e.g., "improve error handling"). Mechanical, well-defined tasks (e.g., a straightforward rename) gain little from the extra phases.
Prompt chaining fits a fixed, identical sequence of subtasks every time. Routing fits inputs that fall into distinct categories needing different handling. Orchestrator-workers fits subtasks that vary unpredictably per input and must be decided dynamically by a central LLM.
Have each agent persist a structured export to a known location; on resume, the coordinator loads a manifest and injects only the relevant state into each subagent's prompt — don't rely on a full raw conversation log (too much context) or semantic vector search (lossy, may miss findings).
The coordinator must emit multiple Task tool calls within a single assistant message — that's the only mechanism that makes the harness run subagents concurrently. Switching to a cheaper model, adding external async infrastructure, or simply instructing the model to "run in parallel" does not guarantee this.
If a coordinator with fully configured AgentDefinitions reasons about delegating but no subagent ever actually executes (with no errors logged), the most likely cause is that "Task" is missing from allowedTools — the model can talk about delegation but has no mechanism to invoke it.
To cut latency while keeping monitoring and debugging centralized, have the coordinator itself spawn parallel subagents and aggregate results — avoid nested/recursive agent hierarchies (subagents spawning their own subagents), which severely hurt observability.
To avoid losing which claim came from which source during synthesis, require subagents to emit explicit structured claim-source mappings that the synthesis agent must preserve — not inline text-prefix conventions, post-hoc log analysis, or unreliable semantic-similarity reconstruction.
When an analysis agent identifies a specific gap (e.g., "missing details on token refresh"), it should report that gap to the coordinator, which triggers targeted follow-up searches and re-runs analysis until coverage is sufficient — not just attach a confidence score and stop, or add an upfront planning agent.
Use reference identifiers pointing to a shared store rather than inlining full raw content into the prompt (bloats context, risks information loss) or relying on callbacks/automatic context inheritance (neither exists in this architecture).
The synthesis agent should render each content type in its natural form — tables for financial comparisons, prose for news narratives — rather than flattening everything into one uniform format like bullet points.
With a diverse and evolving query distribution, let the coordinator's LLM judgment decide dynamically how many and which subagents to invoke per query — static fast-paths, hand-coded pattern routing, and a classifier requiring periodic retraining all break down as patterns evolve.
Specify research goals and quality criteria (coverage breadth, source diversity, recency) rather than prescriptive step-by-step instructions — this lets a capable subagent adapt its own strategy instead of failing rigidly when a pre-specified approach doesn't work.
When a single free-text tool produces inconsistent output formats across different task types, split it into narrowly-scoped tools with explicit input/output contracts (e.g., extract_data_points, summarize_content, verify_claim_against_source) rather than adding an enum parameter, better descriptions, or pre-classification.
Each subagent invocation is a stateless API call with its own isolated context — the coordinator must explicitly inject the prior agents' outputs into the next subagent's prompt, or that subagent will report having no information at all.
If the coordinator already holds all the needed findings in its own context (e.g., from orchestrating prior research), handle a simple follow-up (like summarization) directly rather than spawning a subagent and re-transferring tens of thousands of tokens — that's pure latency overhead.
Pass the synthesis draft together with a structured source index mapping key claims to their source URLs and excerpts — this is the best balance of completeness and efficiency, better than passing all raw content, name-only attribution, or post-hoc citation matching.
In an orchestrator-worker pattern, subagents never call each other directly, and there's no event bus or automatic sibling access — all information flows through the coordinator, which explicitly forwards relevant output into the next subagent's prompt.
If two sources report different numbers over time (e.g., 2022 vs. 2024) and the synthesis agent wrongly flags them as "contradictory," the fix is requiring every data point to carry its own publication or collection date — that lets synthesis reason about trends instead of conflicts.
Preserve the original source characterization and methodological context, and structure the report to separate well-established findings from contested ones — don't average conflicting estimates that use different methodologies, silently filter out uncertain data, or require a rigid two-source minimum.
🗺️ Big picture, from the source — grounded in Anthropic’s official Model Context Protocol architecture (client/server tool calls) plus the standard tool-result and escalation patterns from the CCA-F question bank. Click any number to jump to that principle below.
"The architecture is straightforward: developers can either expose their data through MCP servers or build AI applications (MCP clients) that connect to these servers." — Anthropic, "Introducing the Model Context Protocol," Nov 2024
Read it yourself: Introducing the Model Context Protocol ↗ · Writing effective tools for agents ↗
Grep searches file contents for a pattern (e.g., every call site of eval() or every import of a package) — this is the right choice whenever the task is about content, not filenames. Glob matches file names/paths, Read opens a known file, and Bash executes commands.
For data from a common third-party service (like Jira), integrate an existing MCP server, which provides discoverable, typed tools with managed authentication — building a custom server, exporting to markdown, or using ad-hoc curl calls are all worse fits when a standard integration already exists.
When an agent makes 8-10 sequential tool calls because it has no visibility into what each server contains, expose each server's content catalog as MCP resources (issue summaries, doc hierarchies, schemas) so the agent can browse before acting — don't consolidate servers into a monolith or add keyword-based routing.
Tool selection accuracy degrades as the number of available (especially irrelevant) tools grows. Scope each specialized subagent to only 4-5 role-relevant tools rather than exposing all tools to every agent.
When resuming an old session whose tool results are now outdated (e.g., an order status that has since changed), start a fresh session, inject a structured summary of the prior interaction, and make fresh tool calls before responding — don't strip tool_results from mid-transcript (creates inconsistency) or just instruct the model to "prefer the latest result" (unreliable).
The most reliable escalation criteria are: the customer explicitly requests a human, the issue requires a policy exception, or the agent cannot make meaningful progress — this outperforms a hard retry-count threshold, sentiment analysis, or a rigid rules engine.
When escalating, pass a structured summary — customer ID, root cause, amount, and recommended action — not the raw transcript or just the customer's original complaint, so the human can act immediately without re-investigating.
If a rule "cannot be left to model discretion" (e.g., refunds over $500 must always escalate), enforce it with a hook that intercepts the tool call and blocks it — even a strongly worded system prompt still has a nonzero failure rate and is not compliance-grade.
When a backend action fails (e.g., a refund times out) but other information is already known, explain what's understood, acknowledge the failure honestly, and offer the customer a choice (escalate or retry) — don't promise an outcome that hasn't happened, and don't escalate immediately while ignoring the value already delivered.
If a frustrated customer explicitly asks for a human but the issue is actually simple and resolvable in one tool call, acknowledge the frustration, state that it can be resolved now, and let the customer choose — don't unilaterally act against their stated preference, and don't escalate unnecessarily for a trivial fix.
If the agent "forgets" information mid-flow, the cause is almost always that the full conversation history wasn't included in the latest request — not a missing "remember this" instruction, and not some default two-turn memory limit (no such limit exists).
Return the error message in the tool result's content field with isError set to true, ideally enriched with a structured errorCategory (transient/validation/permission) and an isRetryable flag — not a thrown exception, not a silent empty result, and not an ad-hoc "status" field.
The model decides its next action by reasoning over the tool_result just appended to the conversation — there is no implicit orchestration layer routing by field value, no hard-coded decision tree, and no pre-planned sequence of tool calls fixed at the start.
Summarize resolved topics into a narrative description while keeping full message history only for the currently active issue — a plain sliding window risks silently dropping an earlier issue the customer later asks about again.
When a tool response includes 40+ fields, extract only the fields relevant to the current task and drop the rest — this is more reliable than paraphrasing into prose (loses precision on exact values) or standing up a vector database (overkill for a simple pruning problem).
🗺️ Big picture, from the source — grounded in Anthropic’s official Claude Code best-practices guide (the Explore → Plan → Implement → Commit loop, CLAUDE.md, hooks vs. advisory instructions, subagents). Click any number to jump to that principle below.
"Unlike CLAUDE.md instructions which are advisory, hooks are deterministic and guarantee the action happens." — Anthropic, "Best practices for Claude Code"
Read it yourself: Best practices for Claude Code ↗
--max-turns caps the number of agentic iterations and --max-budget-usd caps the dollar spend per invocation, both enforced natively by Claude Code in headless (claude -p) mode — a CI job timeout or a passive dashboard only monitors from the outside and doesn't enforce either limit directly.
To reduce low-value generated output (e.g., trivial tests), document team standards, fixture conventions, and good-vs-bad examples in CLAUDE.md — fixing the root cause at generation time beats filtering bad output after the fact.
--resume session-name loads that exact named session with all its accumulated context. --continue only resumes the most recent conversation, which may not be the one you want if you've worked on other things since.
If an agent keeps using a built-in tool (like Grep or sed) instead of a specialized MCP tool, the root cause is usually a vague MCP tool description — write a detailed description of capabilities, outputs, and when to use it, rather than removing built-in tools or adding brittle routing rules.
Before grepping for every caller of a function that's re-exported through wrapper modules under different names, first read the library and wrappers to enumerate every exposed alias — grepping only the original name will miss aliased callers.
When an exploration session is interrupted and a small change occurred in the meantime (e.g., a renamed function), resume from the saved transcript (keeps the accumulated context) and explicitly inform the agent of that specific change — don't restart from scratch, and don't resume silently while ignoring the change.
When responses become generic ("typical patterns") instead of referencing the specific classes/functions discovered earlier, summarize the key findings, then spawn a subagent for the next task with that summary as its starting context — don't just /clear (loses everything) or keep going in the degraded context.
Identify the base class/interface first, read it to understand the shared abstraction, then trace the specific implementations relevant to the task — more effective than reading every file sequentially, prioritizing by file size, or only grepping keywords.
To compare two approaches (e.g., two testing strategies) starting from the same analysis baseline, use fork_session to create separate branches — this avoids exploring sequentially in one thread (cross-contamination) or manually recreating context in fresh sessions.
Resume the session (keeps efficiency) and explicitly tell the agent which specific files changed for targeted re-reading (keeps accuracy) — don't re-read everything, don't start fresh, and don't resume silently.
When an agent starts giving inconsistent answers after 30+ minutes of exploration, have it maintain a scratchpad file recording key findings and reference it going forward — more stable than switching to a bigger model, clearing context on a timer, or pre-summarizing every source file upfront.
When a codebase is too large to fit in one context window (e.g., 45 files), delegate well-scoped questions to subagents with fresh context while the main agent retains the high-level architectural understanding — this is the pattern for scaling exploration beyond a single context window.
Let the agent dynamically generate its next investigation step based on what it just discovered — planning the entire path before any exploration (planning blind) or fanning out parallel workers across every layer when you don't yet know which layer is involved both waste effort.
In a file with repetitive patterns (similar docstrings, variable names), the reliable fallback is: Read the whole file, make the change in memory, then Write it back — not a longer match string (still fragile), not replace_all (corrupts other matches), and not appending to the end (wrong location).
Use Grep to find concrete entry points (login, middleware) and trace outward following real import/function-call edges incrementally — reading every file containing broad keywords ("auth", "token") across 800+ files drowns the context in noise.
When a stack trace already points to a specific area, go straight to direct execution — read the trace, read the relevant code, fix the root cause once found. Plan Mode is reserved for genuinely open-ended or architecturally complex problems, not an already-localized bug.
🗺️ Big picture, from the source — grounded in Anthropic’s official structured-outputs and output-consistency documentation (schema-constrained decoding, few-shot examples, retries). Click any number to jump to that principle below.
"Structured outputs constrain Claude’s responses to follow a specific schema, ensuring valid, parseable output for downstream processing." — Anthropic, "Structured outputs" documentation
Read it yourself: Structured outputs ↗ · Increase output consistency ↗
An instruction like "only report high-confidence issues" is followed literally and kills recall. Instead, split the process into a finding stage where the goal is coverage — flag every potential issue with confidence and severity metadata — and a separate downstream stage that applies the threshold.
The Batch API is 50% cheaper but asynchronous (up to a 24-hour window) — appropriate only when that latency remains acceptable for your workflow. Time-sensitive work with a tight SLA (e.g., alerts within 30 minutes) must use the real-time Messages API instead.
When compound phrases are split inconsistently, array lengths vary wildly, or output formats differ each time, add few-shot examples demonstrating the exact canonical format you want — more effective than hard count caps, a bigger model, or setting temperature to 0.
Aggregate accuracy (e.g., 97% overall) can hide a document type or field where accuracy is much lower. Always analyze accuracy by document type and field before automating decisions based on a confidence threshold.
For fields that can be amended over time (e.g., a contract clause changed by a later amendment), capture multiple values each with a source location and effective date — don't force one value, hard-code "the latest always wins," or destructively strip superseded sections.
Retries reliably fix format and structural mistakes the model could have gotten right. They cannot fix a case where the needed information genuinely doesn't exist in the input (e.g., "et al." because the full author list is only in an external document).
Even nullable fields can still get a plausible-but-wrong value hallucinated by the model. Add an explicit instruction to return null when information isn't stated — don't make the field required (that forces the model to invent a value).
When the model misses information that's genuinely present but presented in an unfamiliar structure (inline citations vs. bibliography, methodology embedded in an intro), few-shot examples spanning that format variety raise recall — regex post-processing and retries don't teach the model to recognize new structures.
Add a calculated field (e.g., calculated_total, summed from line items) alongside the stated field (stated_total), and flag records where they differ for human review — don't have the model or a second pass silently reconcile financial data.
When a pipeline tool is sometimes called before a prerequisite tool it depends on, force the correct one first with tool_choice: {"type": "tool", "name": "..."} for that turn, then switch back to "auto" for subsequent turns — don't rely on the order tools are listed in (no such priority exists).
When new categorical values keep appearing (e.g., new property types), add an "other" enum value plus a separate detail string field — this keeps strict validation for common cases while avoiding endless enum maintenance or the validation loss of switching to free text.
When reviewers can only check a fraction of extractions, have the model output field-level confidence scores and calibrate the review threshold using a labeled validation set — this concentrates reviewer attention on errors far more effectively than random sampling or narrow heuristics like "only empty fields."
🗺️ Big picture, from the source — grounded in Anthropic’s official Batch API and context-window documentation. Only 3 principles here, but they cover 15% of the real exam. Click any number to jump to that principle below.
"You can access batch results when all messages have completed or after 24 hours, whichever comes first. Batches expire if processing does not complete within 24 hours." — Anthropic, "Batch processing" documentation
Read it yourself: Batch processing ↗ · Context windows ↗
The Batch API saves 50% but can take up to 24 hours. The core question is always whether results arriving up to 24 hours later remain actionable for your workflow — not result ordering (already correlated via custom_id) or whether a request needs multi-turn refinement.
Worst-case wait-to-be-batched plus the batch processing SLA (up to 24 hours) must fit comfortably within your overall SLA, with a safety margin for reliability. Example: batching every 4 hours plus a 24-hour batch window = a 28-hour worst case, leaving a 2-hour cushion under a 30-hour SLA.
When a small percentage of documents in a large batch fail due to exceeding the context length, the cost-effective fix is to chunk and resubmit only those failed documents, then merge the partial results — not reprocessing the entire batch, and not increasing max_tokens (which controls output length, not input length).
Quick lookup before you walk into the exam room. Skim this table 5 minutes before your mock exam.
| Situation | Choose |
|---|---|
| Search content/pattern inside files | Grep |
| Search by file name/path | Glob |
| Two independent subagents need to run in parallel | Emit both Task tool calls in the SAME message |
| Subtasks vary per input, unpredictable | Orchestrator-workers |
| Same fixed steps every time | Prompt chaining |
| Inputs fall into distinct categories, handled differently | Routing |
| Coordinator can't spawn a subagent, no errors | Check whether "Task" is in allowedTools |
| A mandatory compliance rule (must never be violated) | A deterministic hook blocking the tool call — NOT a prompt |
| When should you escalate to a human? | Customer asks / needs a policy exception / agent is stuck |
| An MCP tool error | content + isError:true + errorCategory + isRetryable |
| The model "forgets" information mid-conversation | Check whether the full messages array is being sent (API is stateless) |
| Reduce low-quality output from the start | Write criteria/examples into CLAUDE.md |
| Cap cost/iterations per headless run | --max-turns / --max-budget-usd |
| Agent picks a built-in tool over a specialized MCP tool | Write a more detailed MCP tool description |
| Edit fails because old_string isn't unique | Read the whole file → edit in memory → Write it back |
| Context degrades after a long session (vague answers) | Summarize, then hand off to a fresh subagent |
| You want to stop missing bugs ("only report high-confidence") | Split the coverage stage from the threshold stage |
| Urgent work needing an alert within minutes | Real-time Messages API, NOT Batch |
| Non-urgent, high-volume, cost-sensitive work | Batch API (50% cheaper, up to 24h) |
| A field may have no information in the source | Instruct: return null instead of guessing (don't require it) |
| Can retries fix "missing information not in the input"? | No — only few-shot examples or better source data can help |
| context_length_exceeded on a few % of documents in a large batch | Chunk and resubmit ONLY the failed documents |
Tip for scenario-based questions: there is almost always one answer that "sounds reasonable but is really a surface-level patch/workaround" and one answer that "fixes the root cause following Anthropic's best practice." Prefer the answer that (1) puts the decision at the right layer of responsibility (deterministic code vs. model reasoning), (2) doesn't waste context or cost unnecessarily, and (3) doesn't break the stateless/context-isolation principle between agents.
Người tổng hợp: TRUNGHM6 — mẹo làm bài, quy tắc loại trừ đáp án, và quy trình đăng ký/đi thi thực tế.
| Từ | Nghĩa |
|---|---|
| Dispute | Tranh chấp, bác bỏ. |
| Accumulate / Accumulated | Tích lũy, dồn lại. |
| Consolidate / Consolidated | Tập lại, gộp lại (merge). |
| Amendments | Chỉnh sửa, điều chỉnh, bổ sung. |
| Reveals | Tiết lộ, làm lộ ra. |
| Propagate | Truyền, lan truyền. |
| Leverage | Tận dụng. |
| Contradictory | Mâu thuẫn. |
| Hate speech | Ngôn từ kích động thù ghét. |
-p, --append-system-prompt — xác định rõ mục tiêu làm gì.⚡ Flow ôn thi nhanh lẹ
Finished reading the principles above? Pick a quiz below and test yourself — each one draws from the same question bank, just in a different format.
One question at a time, with an instant right/wrong check and a running score as you go. Best for your first pass through the question bank.
Start Quiz 1 →A larger, expanded pool with extra scenario variations. Pick a custom question range to drill, and review every wrong answer at the end.
Start Interactive Quiz →The full mock exam: every question on one scrollable page, with domain filters and a final score broken down by domain — the closest simulation of test day.
Start Practice Exam →Suggested order: start with Quiz 1 to get comfortable with the format, use the Interactive Quiz for extra reps on your weak spots, then finish with a timed run of the Practice Exam to simulate the real thing.