# Free Claude Certified Architect – Foundations Practice Questions

*Last updated September 2026 · https://www.certifyforce.com/claude-certified-architect-foundations-practice-exam/free-questions*

18 free Claude Certified Architect – Foundations practice questions from the Certifyforce bank of 300 reviewed questions, spread across the 5 official exam sections in proportion to their weight. Each has the correct answer, an explanation, and the official documentation it was verified against.

## Agentic Architecture & Orchestration (27%)

### Question 1

A platform engineer at Lumen Payments registers this hook so that every tool on the `billing` MCP server is logged and checked before it runs:
```python
options = ClaudeAgentOptions(
    mcp_servers={"billing": billing_server},
    hooks={
        "PreToolUse": [
            HookMatcher(matcher="mcp__billing", hooks=[check_billing_call])
        ]
    },
)
```
Testing shows `check_billing_call` never runs, although Claude calls `mcp__billing__issue_credit` successfully. What is the most likely cause?

- A. `PreToolUse` hooks fire only for built-in tools such as Bash and Write; tools served by MCP servers have to be checked with a `PermissionRequest` hook instead.
- B. SDK callback hooks are applied only to tools listed in `allowed_tools`, so the billing tools must be added there before any hook can intercept them.
- C. The matcher is compared against the tool's input arguments rather than its name, so the callback runs only when an argument contains the text `mcp__billing`.
- D. A matcher made only of letters, digits and underscores is compared as an exact tool name, so it matches no tool; it should be `mcp__billing__.*`.

**Correct answer:** D. A matcher made only of letters, digits and underscores is compared as an exact tool name, so it matches no tool; it should be `mcp__billing__.*`.

**Explanation:** A matcher containing only letters, digits, `_`, `-`, spaces, `,` and `|` is evaluated as an exact string, so `mcp__billing` matches no tool; appending `.*` (as in `mcp__billing__.*`) puts it on the regular-expression path and matches every tool from that server. `PreToolUse` fires for MCP tools too, which use the `mcp__<server>__<tool>` naming pattern, so a separate permission hook is not required. Hook callbacks are not limited to tools in `allowed_tools`, which only pre-approves tools. Matchers filter on the tool name; filtering by arguments must be done inside the callback by inspecting `tool_input`.

**Sources:** [Hooks reference (Claude Code)](https://code.claude.com/docs/en/hooks), [Intercept and control agent behavior with hooks (Agent SDK)](https://code.claude.com/docs/en/agent-sdk/hooks)

### Question 2

A healthcare analytics company's Agent SDK coordinator has a `systemPrompt` that includes a strict data-handling rule: never include patient names in any output. The coordinator delegates chart reviews to a custom `chart-reviewer` subagent (defined with `AgentDefinition`, not a fork) whose `prompt` describes only the review method. Audits find patient names in the subagent's reports, although the coordinator's own replies comply. What should the architect change?

- A. Give the subagent a read-only `tools` list so that it cannot fetch the full patient record, which is where the names in its reports come from.
- B. Set the subagent's `model` to `inherit` so that it runs with the coordinator's model and therefore applies the coordinator's system prompt as well.
- C. Put the rule in the subagent's own `prompt` (or in project CLAUDE.md, which subagents load), since subagents don't get the parent's system prompt.
- D. Set `background` to false so that the subagent runs in the foreground, where it shares the coordinator's system prompt and conversation state.

**Correct answer:** C. Put the rule in the subagent's own `prompt` (or in project CLAUDE.md, which subagents load), since subagents don't get the parent's system prompt.

**Explanation:** A non-fork subagent's context contains its own system prompt (`AgentDefinition.prompt`), the Agent tool's prompt and project CLAUDE.md loaded through setting sources, but not the parent's system prompt or conversation history, so a rule that lives only in the coordinator's `systemPrompt` never reaches it. Restating the rule in the subagent's `prompt`, or keeping it in project CLAUDE.md, puts it in the subagent's context. Restricting tools does not stop names that already arrive in the delegated material from being repeated. `model: inherit` selects the main model but not the main system prompt. Foreground versus background only changes whether Claude waits for the report, not what the subagent sees.

**Sources:** [Subagents in the SDK](https://code.claude.com/docs/en/agent-sdk/subagents), [Create custom subagents](https://code.claude.com/docs/en/sub-agents)

### Question 3

A fintech support team is building a refund-resolution agent on the Claude Messages API with three client-side tools: `lookup_customer`, `get_transaction` and `issue_refund`. The platform engineer is writing the loop that drives the conversation. Which control-flow rule should the loop use to decide whether to keep going?

- A. Stop as soon as the response contains any text block, because text means Claude is now addressing the customer directly.
- B. Run a fixed ten iterations per ticket, which is enough for the longest refund flow the team has seen in testing.
- C. Continue while `stop_reason` is `"tool_use"`, running the requested tools and returning their results, and exit on any other value.
- D. Search each reply for a closing phrase such as "Is there anything else?" and stop the loop once that phrase appears.

**Correct answer:** C. Continue while `stop_reason` is `"tool_use"`, running the requested tools and returning their results, and exit on any other value.

**Explanation:** The canonical client-tool loop keys on `stop_reason`: while it is `"tool_use"`, run each requested tool, send the `tool_result` blocks back and call the API again; any other value means Claude produced a final answer or stopped for a reason the application must handle. Stopping on any text block fails because Claude often writes a sentence such as "Let me check that" in the same response as a tool call. A fixed iteration count is an arbitrary cap that either cuts off long flows or wastes calls on short ones, so it can only be a safety backstop. Matching a closing phrase is parsing natural language to end the loop, which is brittle and breaks whenever the wording changes.

**Sources:** [How tool use works](https://platform.claude.com/docs/en/agents-and-tools/tool-use/how-tool-use-works), [Stop reasons and fallback](https://platform.claude.com/docs/en/build-with-claude/handling-stop-reasons)

### Question 4

An insurer's policy-document generator runs a three-step chain: extract coverage terms from the underwriting file, write a policy outline from those terms, then draft the full policy wording from the outline. When the extraction step misses a required section, such as the flood exclusion, the drafting step writes fluent wording around the gap, and the error surfaces only in legal review days later. What should the architect add?

- A. Merge the three steps into one call with a longer prompt, so that the model reads the whole underwriting file while it writes the final policy wording.
- B. Add a sentence to the drafting prompt asking Claude to point out any coverage section that seems to be missing from the outline it is given.
- C. A programmatic check between steps that confirms the extracted terms and outline contain every required section, and re-runs or stops the chain if not.
- D. Run the drafting step three times in parallel and keep the version of the policy that the other two drafts agree with most closely.

**Correct answer:** C. A programmatic check between steps that confirms the extracted terms and outline contain every required section, and re-runs or stops the chain if not.

**Explanation:** Prompt chaining lets you add programmatic checks, or gates, on intermediate steps to make sure the process is still on track, for example checking that an outline meets its criteria before the document is written; a gate on required sections stops a defective outline from flowing into the draft. Merging the steps gives up the accuracy that chaining buys by making each call an easier task. Asking the drafting step to notice a missing section relies on the model spotting the absence of content it was never given. Voting across drafts built from the same defective outline only repeats the gap.

**Sources:** [Building effective AI agents](https://www.anthropic.com/research/building-effective-agents)

### Question 5

A broadband provider's coordinator splits a customer's three-part complaint (billing error, outage credit, equipment return) into parallel investigation subagents. Each subagent currently starts by calling `get_customer` again, and two of them asked the customer to re-confirm their identity mid-chat. Which two changes best fit a decompose-investigate-synthesize design? Choose 2 answers.

- A. Verify the customer once in the coordinator and pass the verified customer ID, account status and relevant order details in every subagent's delegation prompt.
- B. Give each subagent a narrowly scoped item to investigate and have it return structured findings that the coordinator merges into one unified resolution.
- C. Have each subagent run its own identity verification first, because a subagent's earlier verification is shared with the other subagents through session memory.
- D. Run the three investigations sequentially in one subagent so that the identity check performed for the first item carries over to the remaining two items.
- E. Let each subagent reply to the customer directly as soon as its item is resolved, so the customer receives answers faster and nothing waits for synthesis.

**Correct answers:** A. Verify the customer once in the coordinator and pass the verified customer ID, account status and relevant order details in every subagent's delegation prompt.; B. Give each subagent a narrowly scoped item to investigate and have it return structured findings that the coordinator merges into one unified resolution.

**Explanation:** The pattern is to verify once, then investigate each item in parallel using that shared context, and synthesize a unified resolution; because a non-fork subagent sees only its delegation prompt, the verified customer details must be passed to each one explicitly. Scoped items with structured returns let the coordinator merge the findings into one answer. Subagents do not share session memory, so asking each to verify repeats the friction the customer experienced. Running the items sequentially in one subagent gives up parallelism and mixes three concerns in one context. Having each subagent reply on its own skips synthesis and risks inconsistent answers.

**Sources:** [Subagents in the SDK](https://code.claude.com/docs/en/agent-sdk/subagents), [Building effective AI agents](https://www.anthropic.com/research/building-effective-agents)

## Tool Design & MCP Integration (18%)

### Question 6

In a multi-agent research system, a web search subagent sometimes hits timeouts from the search MCP server, and it also occasionally finds that a paywalled source cannot be accessed at all. Today, every failure goes straight back to the coordinator, which restarts the entire research task. Which two changes should the architect make? Choose 2 answers.

- A. Have the subagent suppress every failure and return whatever results it has as a normal success, so the coordinator never has to deal with errors.
- B. Have the subagent retry transient failures such as timeouts locally, with a bounded number of attempts, before it reports anything to the coordinator.
- C. When a failure cannot be resolved locally, return to the coordinator the error category, the partial results gathered, and what was already attempted.
- D. Have the subagent return a single "search failed" string for any unresolved error so the coordinator's prompt stays short and simple to parse.
- E. Have the coordinator retry the whole research task from the beginning whenever any subagent reports an error, so results are always complete.

**Correct answers:** B. Have the subagent retry transient failures such as timeouts locally, with a bounded number of attempts, before it reports anything to the coordinator.; C. When a failure cannot be resolved locally, return to the coordinator the error category, the partial results gathered, and what was already attempted.

**Explanation:** Transient failures should be recovered locally inside the subagent, and only errors it cannot resolve should be propagated, together with partial results and a record of what was attempted, so the coordinator can decide whether to work around the gap, try another source, or report the limitation. Anthropic's research system resumes from where errors occur rather than restarting, and lets the agent know when a tool is failing so it can adapt. Suppressing failures as normal success hides gaps in coverage from the coordinator and the final report. A bare "search failed" string strips out the category and context the coordinator needs to choose a recovery path. Restarting the whole task for any error is expensive and repeats work that already succeeded.

**Sources:** [How we built our multi-agent research system](https://www.anthropic.com/research/multi-agent-research-system), [Claude Certified Architect – Foundations Exam Guide v1.0 (task statement 5.3)](https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F6nizmqk8tpzpfjvt6qmmav7rh%2Fpublic%2F1783542750%2FClaude+Certified+Architect+%E2%80%93+Foundations+Exam+Guide.pdf)

### Question 7

A solution architect at a logistics firm is reviewing the file-handling guidance in the system prompt of an Agent SDK agent configured with the Read, Write, Edit, Bash, Grep and Glob tools before it is rolled out to 200 engineers. Which three statements should the guidance include? Choose 3 answers.

- A. Use Edit for targeted changes to existing files, giving `old_string` text that appears exactly once in the file, whitespace and indentation included.
- B. Use Write to create new files or to replace a whole file's contents, never to add lines to a file, because it overwrites rather than appends.
- C. When Edit cannot find a unique anchor for a change that must not touch every match, Read the full file and Write the complete corrected content instead of retrying the same Edit.
- D. Use Edit with a regular expression in `old_string` when a change must hit several similar lines, since Edit applies the pattern to each matching line.
- E. Use Write for small changes to large files, because Write merges the provided snippet into the matching section and leaves the rest untouched.

**Correct answers:** A. Use Edit for targeted changes to existing files, giving `old_string` text that appears exactly once in the file, whitespace and indentation included.; B. Use Write to create new files or to replace a whole file's contents, never to add lines to a file, because it overwrites rather than appends.; C. When Edit cannot find a unique anchor for a change that must not touch every match, Read the full file and Write the complete corrected content instead of retrying the same Edit.

**Explanation:** Edit performs exact string replacement and requires `old_string` to match the file exactly and appear once, so it suits targeted modifications; Write creates or overwrites a file with the full content provided and does not append or merge; and when a longer `old_string` still cannot pin down one occurrence and `replace_all` would change matches that must stay, reading the full file and writing the complete corrected content is the reliable fallback. Edit does not use regex or fuzzy matching, so a pattern in `old_string` is treated as literal text. Write does not merge snippets into a file, so using it for a small change would replace the whole file with that snippet, which is why the docs direct partial changes to Edit.

**Sources:** [Tools reference](https://code.claude.com/docs/en/tools-reference), [Claude Certified Architect – Foundations Exam Guide v1.0 (task statement 2.5)](https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F6nizmqk8tpzpfjvt6qmmav7rh%2Fpublic%2F1783542750%2FClaude+Certified+Architect+%E2%80%93+Foundations+Exam+Guide.pdf)

### Question 8

A SaaS company's Claude Code project has a QA subagent in `.claude/agents/qa-browser.md` that drives a browser through the Playwright MCP server. The platform engineer wants the browser tools available only to that subagent, so the main conversation can neither call them nor carry their tool descriptions. What should the engineer do?

- A. Define the Playwright server inline in the qa-browser subagent's mcpServers frontmatter instead of adding it to the project's .mcp.json file.
- B. Add the Playwright server to .mcp.json and write a CLAUDE.md rule telling the main conversation to delegate all browser work to qa-browser.
- C. Add the Playwright server at user scope in ~/.claude.json, because user-scoped servers load only inside subagents that reference them by name.
- D. Add the Playwright server to .mcp.json and set `tools: mcp__playwright__*` in the qa-browser frontmatter so the server belongs to the subagent.

**Correct answer:** A. Define the Playwright server inline in the qa-browser subagent's mcpServers frontmatter instead of adding it to the project's .mcp.json file.

**Explanation:** An MCP server defined inline in a subagent's mcpServers field connects when that subagent starts and disconnects when it finishes; the subagent gets the tools and the parent conversation does not, which is the documented way to keep a server out of the main conversation. Adding it to .mcp.json and relying on a CLAUDE.md rule leaves the tools callable in the main conversation. User scope makes the server available in all of the developer's projects and in the main session, not only inside subagents. Setting tools on the subagent restricts what the subagent gets but does nothing to remove the .mcp.json server from the main conversation.

**Sources:** [Create custom subagents](https://code.claude.com/docs/en/sub-agents), [Connect Claude Code to tools via MCP](https://code.claude.com/docs/en/mcp)

## Claude Code Configuration & Workflows (20%)

### Question 9

A platform engineer at a logistics company is migrating 50 services from a homegrown retry helper to a shared resilience library. Two integration approaches are viable, and an earlier attempt run directly in one long session exhausted the context halfway through. Which three actions together form the best workflow? Choose 3 answers.

- A. Start in plan mode so Claude can investigate the call sites and compare the two approaches before any file is edited
- B. Have the verbose discovery of call sites handled by the Explore subagent so that only its summaries reach the main context
- C. After reviewing and approving the plan, let Claude implement the agreed approach and run the tests as it works
- D. Skip planning and run the whole migration directly in acceptEdits mode, running `/compact` after every service is done
- E. Add "plan carefully before editing" to CLAUDE.md and then begin in the default mode, trusting Claude to plan on its own

**Correct answers:** A. Start in plan mode so Claude can investigate the call sites and compare the two approaches before any file is edited; B. Have the verbose discovery of call sites handled by the Explore subagent so that only its summaries reach the main context; C. After reviewing and approving the plan, let Claude implement the agreed approach and run the tests as it works

**Explanation:** The guide's recommended pattern combines plan mode for investigation, the Explore subagent to isolate verbose discovery and avoid exhausting context, and direct execution of the approved plan for implementation. Plan mode compares the two approaches with edits blocked, Explore returns summaries instead of raw search output, and approving the plan moves Claude into implementing with tests. Running everything directly with repeated `/compact` commits to an approach unreviewed and relies on lossy summaries to recover context. A CLAUDE.md reminder is only guidance and does not provide the edit block or the plan approval step that plan mode enforces.

**Sources:** [Best practices for Claude Code](https://code.claude.com/docs/en/best-practices), [Create custom subagents (built-in Explore subagent)](https://code.claude.com/docs/en/sub-agents), [Choose a permission mode (plan mode)](https://code.claude.com/docs/en/permission-modes)

### Question 10

A gaming studio's pre-merge check runs `claude -p` with `--output-format json` and `--json-schema`, then passes when `jq '.structured_output.findings // []'` returns an empty list. An audit finds that several runs which had failed, including one with an authentication error, were recorded as clean reviews. Which two changes should the platform engineer make? Choose 2 answers.

- A. Fail the check when `claude` exits with a non-zero status, because Claude Code exits non-zero when the run itself fails
- B. Fail the check, or mark the review incomplete, when `structured_output` is missing, instead of treating it as zero findings
- C. Keep the empty-list default, because the schema marks `findings` as required, so a missing field can only mean the code is clean
- D. Rerun the command until `findings` is non-empty, since a review that returns no findings at all is the most likely sign of a fault
- E. Fall back to scanning the `result` text with a regular expression for file paths whenever the structured output field is absent

**Correct answers:** A. Fail the check when `claude` exits with a non-zero status, because Claude Code exits non-zero when the run itself fails; B. Fail the check, or mark the review incomplete, when `structured_output` is missing, instead of treating it as zero findings

**Explanation:** Claude Code exits with a non-zero code when a run fails and omits `structured_output` when a run ends without valid structured output, and the docs tell scripts to check for the field before using it, so both signals must fail the check rather than default to an empty result. Treating a missing field as zero findings is exactly how failed runs became clean reviews; the schema only constrains output that was produced. Rerunning until findings appear treats a legitimately clean pull request as a fault. Regex fallback on `result` replaces validated data with guesses taken from text, which may itself be an error message.

**Sources:** [Run Claude Code programmatically](https://code.claude.com/docs/en/headless), [CLI reference](https://code.claude.com/docs/en/cli-reference)

### Question 11

A gaming studio's engine team is cleaning up a 450-line CLAUDE.md. They want always-loaded content limited to standards that apply to nearly every task, with task-specific workflows moved into skills. Which two items should move from CLAUDE.md into skills? Choose 2 answers.

- A. A 35-step checklist for cutting a console release, used about once a month by the release engineer
- B. The rule that every change must be built with `make build-all` before committing to any branch
- C. A detailed reference for the legacy save-file format, needed only when someone writes a migration for it
- D. The convention that commit messages start with a ticket key such as `ENG-1234` followed by a summary
- E. The note that the repository uses 4-space indentation in C++ files and 2-space indentation in Lua

**Correct answers:** A. A 35-step checklist for cutting a console release, used about once a month by the release engineer; C. A detailed reference for the legacy save-file format, needed only when someone writes a migration for it

**Explanation:** CLAUDE.md is loaded in every session, so the docs advise keeping it to facts Claude needs broadly and moving multi-step procedures or rarely needed domain knowledge into skills, whose bodies load only when invoked or judged relevant. The monthly release checklist is a task-specific procedure and the save-file format reference is occasional domain knowledge, so both fit skills. The build-before-commit rule, the commit-message convention and the indentation rules apply to nearly every change, so they belong in always-loaded CLAUDE.md. Moving them to skills would leave Claude without them on ordinary tasks.

**Sources:** [Best practices for Claude Code](https://code.claude.com/docs/en/best-practices), [Extend Claude with skills](https://code.claude.com/docs/en/skills)

### Question 12

A ride-sharing company's mobile repository has `services/payouts/CLAUDE.md` with payout-specific conventions. An engineer launches Claude Code at the repository root, runs `/context`, and sees only the root CLAUDE.md under Memory files. She concludes the payouts file is broken. What should the platform engineer tell her?

- A. Subdirectory CLAUDE.md files load only when they are imported, so add `@services/payouts/CLAUDE.md` to the root CLAUDE.md
- B. Claude Code recognizes only `CLAUDE.md` at a repository root, so move the payouts conventions to `services/payouts/.claude/CLAUDE.md`
- C. Subdirectory files load only when Claude Code is launched from that directory, so payouts work must always start in `services/payouts/`
- D. Subdirectory CLAUDE.md files load on demand, once Claude reads or edits a file in that directory, so they do not appear at launch

**Correct answer:** D. Subdirectory CLAUDE.md files load on demand, once Claude reads or edits a file in that directory, so they do not appear at launch

**Explanation:** Claude Code loads CLAUDE.md files from the working directory and the directories above it at launch, and it loads CLAUDE.md files in subdirectories on demand once Claude reads, writes or edits a file there. The docs note that such a file does not appear under Memory files because it is not loaded at launch; a `Loaded` line appears when it does load, so she can test it by asking Claude to read a payouts file. Importing it from the root would load it in every session and waste context for unrelated work. Subdirectory CLAUDE.md files are supported where they are, so no move is needed. Launching from `services/payouts/` also loads the file, but it is not the only way to get it.

**Sources:** [How Claude remembers your project (CLAUDE.md and memory)](https://code.claude.com/docs/en/memory), [Set up Claude Code in a monorepo or large codebase](https://code.claude.com/docs/en/large-codebases)

## Prompt Engineering & Structured Output (20%)

### Question 13

A logistics firm, Brightline Freight, sends bills of lading to Claude with a single `extract_shipment` tool defined and no `tool_choice` set. Most responses contain a `tool_use` block, but some return only a text block such as "This document looks like a customs declaration rather than a bill of lading." with `stop_reason` of `end_turn`. What is the most likely cause?

- A. The tool is not marked `strict: true`, so Claude may answer in prose whenever its input would not fully satisfy the schema.
- B. The `max_tokens` value is too low, so Claude drops the tool call and returns the shorter text summary that fits the budget.
- C. When tools are provided without `tool_choice`, the default is `auto`, which lets Claude decide to answer with text instead.
- D. The schema contains optional fields, and Claude skips the tool call when it cannot fill every optional property from the document.

**Correct answer:** C. When tools are provided without `tool_choice`, the default is `auto`, which lets Claude decide to answer with text instead.

**Explanation:** With tools present and no `tool_choice`, the API uses `auto`, which allows Claude to decide whether to call a tool or respond directly, so an unexpected document can produce a text-only answer. `strict: true` governs whether tool inputs match the schema; it does not decide whether a tool is called. A low `max_tokens` would surface as `stop_reason: "max_tokens"`, not a clean `end_turn`. Optional fields are simply omitted when absent and do not make Claude skip the tool.

**Sources:** [Define tools](https://platform.claude.com/docs/en/agents-and-tools/tool-use/define-tools)

### Question 14

A telecom company's support agent tags incoming tickets for escalation using the instruction "Escalate urgent tickets to tier 2." Tier 2 is flooded with angry-sounding billing questions, while some calmly worded reports of complete service outages are missed. What should the support-automation lead change?

- A. Define urgent as an outage, a security incident or a failed payment, and state that routine billing questions are not urgent.
- B. Tell the agent to treat strongly negative customer sentiment as the main signal that a ticket is urgent and needs escalation.
- C. Have the agent rate its confidence that each ticket is urgent and escalate only those rated at least 90 percent likely.
- D. Add "Be careful and conservative when deciding what counts as urgent" to the start of the current escalation instruction.

**Correct answer:** A. Define urgent as an outage, a security incident or a failed payment, and state that routine billing questions are not urgent.

**Explanation:** "Urgent" is undefined, so Claude infers it from tone; explicit categorical criteria (outage, security incident, failed payment, and what is not urgent) let it classify calm outage reports and angry billing questions correctly. Treating negative sentiment as the urgency signal is the very failure being observed, because tone does not measure business impact. A confidence threshold filters on self-assessment while urgency itself stays undefined. "Be careful and conservative" is a general instruction that does not tell Claude where the line is.

**Sources:** [Prompting best practices](https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/claude-prompting-best-practices), [Increase output consistency](https://platform.claude.com/docs/en/test-and-evaluate/strengthen-guardrails/increase-consistency)

### Question 15

An ML engineer at a clinic network adds the following tool definition to a Messages API request:
```python
tools = [{
    "name": "book_appointment",
    "description": "Books a clinic appointment for an existing patient. ...",
    "input_schema": {
        "type": "object",
        "properties": {
            "patient_id": {"type": "string"},
            "slot": {"type": "object", "properties": {
                "date": {"type": "string"}, "time": {"type": "string"}}},
        },
        "required": ["patient_id", "slot"],
    },
    "input_examples": [
        {"patient_id": "P-10422", "slot": {"date": "2026-11-03", "time": "09:30"}},
    ],
}]
```
Which two statements about the `input_examples` field are true? Choose 2 answers.

- A. Each entry must be valid against `input_schema`; an invalid example causes the request to fail with a 400 error.
- B. The examples add to the prompt tokens of every request that includes this tool definition.
- C. With `input_examples` present, the description can be dropped, because the examples alone carry the usage guidance.
- D. Claude is constrained to produce inputs that exactly match one of the listed examples when it calls this tool.
- E. The same field can also be attached to server tools such as web search or code execution to steer their queries.

**Correct answers:** A. Each entry must be valid against `input_schema`; an invalid example causes the request to fail with a 400 error.; B. The examples add to the prompt tokens of every request that includes this tool definition.

**Explanation:** Per the Define tools page, every input example must validate against the tool's `input_schema` or the API returns a 400 error, and examples add prompt tokens (roughly 20 to 50 for simple examples and more for nested ones). Clear descriptions remain the most important factor in tool performance, and examples complement them rather than replacing them. Examples demonstrate usage; they do not restrict Claude's inputs to the listed values. Input examples are supported on user-defined client tools but not on server tools such as web search or code execution.

**Sources:** [Define tools](https://platform.claude.com/docs/en/agents-and-tools/tool-use/define-tools)

## Context Management & Reliability (15%)

### Question 16

An insurance company auto-approves claim extractions whose calibrated field confidence is above its threshold, and humans review only low-confidence fields. Six weeks later, a provider changes its invoice layout and confident but wrong `procedure_code` values start flowing through unreviewed. Which practice would have detected this pattern earliest?

- A. Routing more low-confidence fields to reviewers, since errors in auto-approved output usually first show up as a rise in low-confidence fields that reviewers notice.
- B. Having the extraction model re-check each auto-approved record in the same conversation and flag any field it is no longer confident about after a second look.
- C. Tracking customer complaints and claim appeals per provider, which shows when an extraction problem has started to change the results of claim adjudication.
- D. Sending a stratified random sample of auto-approved, high-confidence extractions, spread across providers, document types and fields, to human review on an ongoing basis.

**Correct answer:** D. Sending a stratified random sample of auto-approved, high-confidence extractions, spread across providers, document types and fields, to human review on an ongoing basis.

**Explanation:** Stratified random sampling of high-confidence output keeps measuring the error rate in extractions nobody otherwise reviews, and spreading the sample across segments surfaces novel error patterns such as a layout change. Reviewing more low-confidence fields cannot catch errors the model is confident about. Re-checking in the same conversation is self-review, which tends to repeat the original reasoning rather than catch its mistakes. Complaints and appeals are lagging signals that arrive only after wrong data has already affected customers.

**Sources:** [Demystifying evals for AI agents - Anthropic](https://www.anthropic.com/research/demystifying-evals-for-ai-agents), [Claude Certified Architect – Foundations Exam Guide v1.0 (task statement 5.5)](https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F6nizmqk8tpzpfjvt6qmmav7rh%2Fpublic%2F1783542750%2FClaude+Certified+Architect+%E2%80%93+Foundations+Exam+Guide.pdf)

### Question 17

A venture-capital firm's due-diligence system runs five subagents in parallel (financials, patents, litigation, news and hiring). When the litigation subagent fails after exhausting its retries, the coordinator aborts the entire run and discards the four analyses that had already completed. What is the better design?

- A. Restart all five subagents from the beginning so that the final report is built from one consistent set of fresh results
- B. Drop the litigation section quietly and publish the report from the four completed analyses as though it were complete
- C. Continue with the four completed analyses and record the litigation gap so the final report clearly states what is missing
- D. Have the coordinator write the litigation section itself from general knowledge so that the report has no empty sections

**Correct answer:** C. Continue with the four completed analyses and record the litigation gap so the final report clearly states what is missing

**Explanation:** Terminating an entire workflow because one subagent failed is an anti-pattern, and so is silently suppressing the failure; the coordinator should keep the completed work and surface the gap explicitly. Anthropic notes that restarting agents from the beginning is expensive and frustrating, and that systems should resume from where errors occurred. Restarting all five subagents throws away good work and may hit the same failure again. Dropping the section quietly hides a material gap from the reader. Writing the section from general knowledge presents unsourced content as if it were researched.

**Sources:** [How we built our multi-agent research system](https://www.anthropic.com/research/multi-agent-research-system), [Claude Certified Architect – Foundations Exam Guide v1.0 (task statement 5.3)](https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F6nizmqk8tpzpfjvt6qmmav7rh%2Fpublic%2F1783542750%2FClaude+Certified+Architect+%E2%80%93+Foundations+Exam+Guide.pdf)

### Question 18

In a biotech company's research system, a document-analysis subagent returns 6,000-word narratives that include its full reasoning chain. The report-writer agent has a tight context budget and, once four of these narratives arrive, starts dropping citations. Which change best fixes the problem at its source?

- A. Have the report-writer compact each incoming narrative into a short summary before it begins drafting the final report
- B. Truncate each narrative to its first 1,500 words before passing it on, since subagents tend to state their conclusions first
- C. Give the report-writer the same document tools as the analysis subagent so it can re-read the source documents when needed
- D. Change the analysis subagent to return structured output: the key facts, their citations and a relevance score for each

**Correct answer:** D. Change the analysis subagent to return structured output: the key facts, their citations and a relevance score for each

**Explanation:** When a downstream agent has a limited context budget, the upstream agent should return structured, condensed data (key facts, citations, relevance) rather than verbose content and reasoning chains; Anthropic describes subagents exploring extensively but returning only a distilled summary to the lead agent. Compacting in the report-writer happens after the verbose text has already consumed its budget and is itself a lossy step that can drop citations. Truncating to a fixed word count is arbitrary and can cut exactly the citations that were being lost. Giving the report-writer the analysis tools duplicates the subagent's work and fills its small context with raw documents.

**Sources:** [Effective context engineering for AI agents](https://www.anthropic.com/research/effective-context-engineering-for-ai-agents), [How we built our multi-agent research system](https://www.anthropic.com/research/multi-agent-research-system)

## Related pages

- [Claude Certified Architect – Foundations practice exam](https://www.certifyforce.com/claude-certified-architect-foundations-practice-exam)
- [Practice exam packs](https://www.certifyforce.com/practice-exams)
- [Official Claude Certified Architect – Foundations exam guide](https://anthropic-partners.skilljar.com/claude-certified-architect-foundations-certification)

Certifyforce is an independent study resource and is not affiliated with, endorsed by or sponsored by Anthropic. Claude is a trademark of Anthropic.