MCP Integration in Claude Code: Scopes, Resources and Built-in Tools

πŸ“š Exam guide v1.0 (July 2026)πŸ”„ Checked against official sources: 11 Nov 2026✏️ Updated: 12 Nov 2026⏱️ 8 min read🎯 Official objectives 2.4 and 2.5

πŸ‘‹ In plain words: MCP lets Claude Code plug into your team's systems, such as GitHub, Jira or a database, the same way for everyone. This lesson covers where to configure those connections, how to keep passwords out of Git, and which built-in tool to use for searching code.

The Model Context Protocol (MCP) connects Claude to your systems. The exam checks that you can configure servers at the right scope, keep secrets out of git, use resources to cut wasted calls, and pick the right built-in tool (Task Statements 2.4 and 2.5).

πŸ“– What You’ll Learn: You will be able to configure MCP servers at the right scope, keep secrets out of git, and pick the right built-in tool for each job.

πŸ”‘ Key terms

  • MCP (Model Context Protocol): A standard that connects Claude to tools and data, like USB for AI.
  • .mcp.json: A file in your repository listing the MCP servers your whole team shares.
  • Environment variable: A secret or setting stored on your machine, for example GITHUB_TOKEN, not in the code.
  • Resource: Read-only content an MCP server offers, such as a list of database tables.
  • Grep / Glob: Built-in tools. Grep searches inside files; Glob finds files by name.

πŸ“– The story in this lesson

Ravi wants every ShopNest developer's Claude Code to reach the team's GitHub and Jira, without anyone committing a password to the repository.

πŸ’‘ Think of it like this

MCP is like a universal power socket. Any appliance (server) with the standard plug works in any room (Claude client). .mcp.json is the house wiring plan everyone shares. Your personal desk lamp stays in your own room, ~/.claude.json.

πŸ”Œ Project scope vs user scope

ScopeFileUse for
Project.mcp.json in the repo (committed)Shared team servers (GitHub, Jira, internal docs)
User~/.claude.jsonPersonal or experimental servers
{
  "mcpServers": {
    "github": {
      "command": "github-mcp-server",
      "env": { "GITHUB_TOKEN": "${GITHUB_TOKEN}" }
    }
  }
}

Environment-variable expansion (${GITHUB_TOKEN}) keeps credentials out of version control. Tools from all configured servers are discovered when Claude Code connects and are available at the same time.

🌍 Real-world example: Sharing GitHub without sharing the token

Ravi commits .mcp.json with the GitHub server, and the token written as a variable. Each developer sets their own GITHUB_TOKEN locally. Ravi's experimental weather server stays in his personal ~/.claude.json.

{"mcpServers": {"github": {"command": "github-mcp-server",
  "env": {"GITHUB_TOKEN": "${GITHUB_TOKEN}"}}}}

πŸ› οΈ Tools vs resources

  • Tools perform actions (search tickets, create an issue).
  • Resources expose content catalogues β€” issue summaries, documentation trees, database schemas β€” so the agent can see what exists without exploratory tool calls.

If the agent keeps choosing built-in Grep over your more capable MCP search tool, improve the MCP tool’s description. For standard systems like Jira, prefer a maintained community server; build custom servers for team-specific workflows.

🌍 Real-world example: 12 calls to find the tables

Claude made 12 exploratory calls just to learn which database tables exist. Ravi exposes the table list as an MCP resource instead. Claude can now see it straight away and goes straight to the right table.

MCP architecture in Claude CodeClaude Code (host)built-in: Read Β· Write Β· EditBash Β· Grep Β· GlobMCP clientdiscovers tools fromall servers at startGitHub server (team).mcp.json in the repotoken via ${GITHUB_TOKEN}Notes server (personal)~/.claude.jsononly on your machineRemote docs serverStreamable HTTPtools + resources (catalogues)stdiostdioHTTPTools = actionsResources = what existsPrompts = user templates
Figure: Claude Code's MCP client connects to team, personal and remote servers at the same time. Swipe sideways to see the whole diagram.

πŸ› οΈ Choosing built-in tools

NeedTool
Search file contents (callers, error strings, imports)Grep
Find files by name or path pattern (**/*.test.tsx)Glob
Load a whole fileRead
Create or overwrite a fileWrite
Targeted change via unique anchor textEdit (fallback: Read + Write when the anchor isn’t unique)
Run commands and testsBash

Explore incrementally: Grep for entry points, then Read along imports. To trace usage through wrapper modules, list all exported names first, then Grep for each.

🌍 Real-world example: Finding every test that creates a user

Ravi needs every *.spec.ts file that calls createUser(. First Glob, to find files by name pattern. Then Grep, to search inside those files for the text. Reading every file one by one would waste time and context.

🚫 Common beginner mistake: Writing an API token directly in .mcp.json. Use environment-variable expansion, so the committed file contains no secrets.

πŸ› οΈ Try it yourself (about 10 minutes)

  1. In a test repository, create .mcp.json with one server that uses ${MY_TOKEN}.
  2. Set MY_TOKEN in your terminal, not in the file.
  3. Start Claude Code and run /mcp to see the server.
  4. Check with git diff that no real token appears.

βœ… You are done when: /mcp lists the server and the committed file contains only the variable name.

πŸ§ͺ Exam-Style Practice Questions

Try these before opening the answers. They use the same scenario style as the real exam.

Question 1. Where should a shared team GitHub MCP server be configured, and how is its token handled?

  • A. .mcp.json with the token inline, but git-ignored
  • B. ~/.claude.json with the token inline
  • C. CLAUDE.md
  • D. Project .mcp.json committed, using ${GITHUB_TOKEN} env expansion
Show answer

Answer: D. Project scope makes it shared, and env expansion keeps secrets out of git. B is personal scope and the token is inline. C isn't where servers are configured. A is no longer shared, and it's a fragile secret-handling pattern.

Question 2. You need to find every file named *.spec.ts, then find which of them call createUser(. Which tools, in order?

  • A. Grep, then Glob
  • B. Bash ls only
  • C. Glob, then Grep
  • D. Read all files
Show answer

Answer: C. Glob matches path patterns, and Grep searches contents. A reverses their roles. D is wasteful. B can't search contents well.

Question 3. The agent makes 12 exploratory calls to discover which database tables exist. What's the better design?

  • A. Increase max_tokens
  • B. Put the full DB dump in the prompt
  • C. Add a list_everything tool
  • D. Expose the schema catalogue as an MCP resource
Show answer

Answer: D. Resources expose catalogues without needing exploratory calls. C is a blunt tool that may be huge. B wastes context and goes stale. A is unrelated.

πŸ“ Assignment

Do these tasks in order. Each one has a Done when check, so you know when it is complete. The stretch task is optional but close to what the exam expects from an architect. Keep your answers in one notes file or Git repository, and revisit them in your final week of revision together with the cheat sheet in the last lesson of this course.

  1. Task 1: Create a project .mcp.json that uses ${GITHUB_TOKEN} and a personal server in user scope. Confirm both appear with /mcp.
    βœ… Done when: /mcp lists both servers, and your committed .mcp.json contains no real token.
  2. Task 2: Find all callers of one function with Grep and all test files with Glob in a repo you know.
    βœ… Done when: You recorded the exact Grep and Glob patterns you used and how many matches each returned.
  3. Stretch: expose a list of documents as an MCP resource and compare the number of tool calls before and after.
    βœ… Done when: You counted tool calls before and after adding the resource, and the count went down.

❓ Frequently Asked Questions

πŸ€” Where do shared MCP servers go?

In the project's .mcp.json, committed to the repository, with secrets supplied through environment-variable expansion.

πŸ€” What is an MCP resource?

Read-only content the server exposes, such as a catalogue or schema, so the agent can see what exists without exploratory calls.

πŸ€” What is the difference between Grep and Glob?

Grep searches inside files for text. Glob finds files whose names or paths match a pattern.

πŸ€” What if Edit cannot find a unique match?

Read the whole file, then Write the corrected content.

🏁 Summary

  • Team servers in .mcp.json with ${ENV}; personal servers in ~/.claude.json.
  • Resources for catalogues, tools for actions.
  • Grep = contents, Glob = paths, Edit needs unique anchors.
πŸ“ Test yourself: Mock Test 2 Β· Mock Test 3 (30 scenario-based questions in 60 minutes, with explanations).

Next, continue with CLAUDE.md Configuration Guide: Hierarchy, @import and Path-Specific Rules.

🎬 Prefer video? Watch QA, automation and AI testing tutorials on the SQA Tools YouTube channel.

Independent study material by SQA Tools. Not affiliated with, endorsed by or sponsored by Anthropic. Claude is a trademark of Anthropic. Mock questions are original practice items, not real exam content. Exam facts checked against Anthropic's official exam guides and certification FAQ on 11 November 2026.

MCP Tool Error Handling: isError, Error Categories and Retries

πŸ“š Exam guide v1.0 (July 2026)πŸ”„ Checked against official sources: 11 Nov 2026✏️ Updated: 12 Nov 2026⏱️ 7 min read🎯 Official objective 2.2

πŸ‘‹ In plain words: Tools fail: servers time out, inputs are wrong, rules forbid an action. If a tool just says 'Operation failed', Claude can't tell whether to retry, fix something, or explain to the user. This lesson shows how to return errors that help Claude recover sensibly.

When a tool fails, the agent can only recover sensibly if it knows why. A generic “Operation failed” leads to pointless retries of policy violations and early surrender on simple timeouts. This is Task Statement 2.2.

πŸ“– What You’ll Learn: You will be able to design MCP tool errors that let Claude retry what is worth retrying and explain or escalate the rest.

πŸ”‘ Key terms

  • MCP server: A small program that offers tools (and data) to Claude through the Model Context Protocol.
  • isError: A flag on a tool result saying 'this call failed'.
  • Transient error: A temporary failure, such as a timeout, that may work if you try again.
  • Business error: The action broke a rule, such as a refund outside the 30-day window. Retrying won't help.
  • Retryable: Whether trying again could succeed.

πŸ“– The story in this lesson

ShopNest's refund tool can fail in four ways: the payment server is slow, the date was typed wrongly, the order is outside the 30-day window, or the bot lacks permission. Each failure needs a different response.

πŸ’‘ Think of it like this

A good error is like a helpful shop assistant. 'Sorry, the till is rebooting, try again in a minute' (temporary). 'That date isn't valid, please use DD/MM' (fix the input). 'We can't refund after 30 days' (a rule). 'Only the manager can do that' (permission). 'Error' on its own helps nobody.

🚨 The isError pattern

MCP tools signal failure with isError: true in the tool result. Put structured metadata in the content:

{
  "isError": true,
  "content": [{"type": "text", "text": "{\"errorCategory\": \"business\", \"isRetryable\": false, \"message\": \"Refund window is 30 days; this order was delivered 41 days ago.\", \"customerMessage\": \"This order is outside our 30-day refund window.\"}"}]
}

🌍 Real-world example: A refund outside the window

Instead of throwing a raw error, the refund tool returns a result with isError set, a category, whether a retry could work, and a message the bot can pass on to the customer.

{"isError": true, "errorCategory": "business", "isRetryable": false,
 "customerMessage": "This order is outside our 30-day refund window."}

🚨 Four error categories

CategoryExampleRetryable?Agent should…
TransientTimeout, 503YesRetry with backoff
ValidationBad date formatYes, after fixing inputCorrect and retry
BusinessPolicy limit exceededNoExplain or escalate
PermissionNot authorisedNoEscalate or request access

🌍 Real-world example: Four failures, four responses

A timeout: retry after a short wait. A date in the wrong format: correct it and retry. Outside the refund window: explain to the customer, no retry. No permission: escalate to a human. One category field lets Claude choose correctly every time.

🚨 Empty result is not an error

“No orders found for this customer” is a successful query with zero matches. A database timeout is an access failure. Reporting empty results as errors triggers retries; reporting failures as empty results hides problems.

🌍 Real-world example: 'No orders' vs 'database down'

A new customer has no orders, so the search correctly returns an empty list as a success. On another day the database times out, which is an error. When ShopNest once reported both as 'no orders', customers were told they had never ordered while the database was down.

πŸ“˜ Local recovery in multi-agent systems

Subagents should handle transient failures themselves and propagate only what they can’t resolve β€” with what they attempted and any partial results β€” so the coordinator can decide what to do next.

🌍 Real-world example: The subagent retries first

A search subagent hits a timeout. It retries twice by itself, which works most of the time. Only when it still fails does it report to the coordinator, saying what it tried and including the 3 results it did get.

🚫 Common beginner mistake: Returning an empty list when a tool actually failed. It hides the failure, and Claude will confidently say 'nothing found'.

πŸ› οΈ Try it yourself (about 8 minutes)

  1. List three ways a tool you use could fail.
  2. Label each one transient, validation, business or permission.
  3. Write the JSON error for the business case, including a customer-friendly message.

βœ… You are done when: each failure has a category and a retryable yes or no, and the JSON includes isError.

πŸ§ͺ Exam-Style Practice Questions

Try these before opening the answers. They use the same scenario style as the real exam.

Question 1. An MCP tool times out. What should it return?

  • A. A Python stack trace
  • B. A result with isError: true and structured metadata (category transient, retryable)
  • C. An empty array
  • D. Nothing; let the client hang
Show answer

Answer: B. It's structured and actionable. C disguises a failure as "no data". A is noisy and possibly leaks internals. D is broken behaviour.

Question 2. A search returns no matching orders for a valid customer. How should the tool report this?

  • A. As an error with isRetryable: true
  • B. By throwing a timeout
  • C. As a successful result with an empty list
  • D. As a permission error
Show answer

Answer: C. A valid query with zero matches is a success. Treating it as an error (A, D, B) triggers pointless retries or escalation.

Question 3. Which error should not be retried?

  • A. Network timeout
  • B. 503 Service Unavailable
  • C. Rate limited
  • D. "Refund exceeds the 30-day policy window"
Show answer

Answer: D. A business-rule violation: retrying won't change the outcome, so explain it or escalate. A, B and C are transient.

πŸ“ Assignment

Do these tasks in order. Each one has a Done when check, so you know when it is complete. The stretch task is optional but close to what the exam expects from an architect. Keep your answers in one notes file or Git repository, and revisit them in your final week of revision together with the cheat sheet in the last lesson of this course.

  1. Task 1: List three failures your own tools can produce and classify each as transient, validation, business or permission.
    βœ… Done when: Each failure is assigned exactly one category and marked retryable or not retryable, with a reason.
  2. Task 2: Write the JSON error body for a business-rule failure, including a customer-friendly message.
    βœ… Done when: Your JSON includes isError, errorCategory, isRetryable and a message a customer could read without confusion.
  3. Stretch: make a subagent retry a transient error locally and report partial results to the coordinator only if it still fails.
    βœ… Done when: A simulated timeout is retried inside the subagent, and only a persistent failure reaches the coordinator with partial results.

❓ Frequently Asked Questions

πŸ€” What is the isError flag in MCP?

A field on the tool result that tells the client and Claude the tool call failed.

πŸ€” Which errors should not be retried?

Business-rule violations and permission errors. Retrying cannot change their outcome.

πŸ€” Is no results an error?

No. A valid query that matches nothing is a successful result with an empty list.

πŸ€” Why is 'Operation failed' a bad error message?

It hides whether the failure is temporary, caused by bad input or a policy, so the agent cannot choose a sensible recovery.

🏁 Summary

  • Return isError plus errorCategory, isRetryable and a readable message.
  • Business and permission errors are not retryable.
  • Empty β‰  failure.
πŸ“ Test yourself: Mock Test 2 Β· Mock Test 3 (30 scenario-based questions in 60 minutes, with explanations).

Next, continue with MCP Integration in Claude Code: Scopes, Resources and Built-in Tools.

🎬 Prefer video? Watch QA, automation and AI testing tutorials on the SQA Tools YouTube channel.

Independent study material by SQA Tools. Not affiliated with, endorsed by or sponsored by Anthropic. Claude is a trademark of Anthropic. Mock questions are original practice items, not real exam content. Exam facts checked against Anthropic's official exam guides and certification FAQ on 11 November 2026.

Claude Tool Design: Descriptions, Tool Distribution and tool_choice

πŸ“š Exam guide v1.0 (July 2026)πŸ”„ Checked against official sources: 11 Nov 2026✏️ Updated: 12 Nov 2026⏱️ 8 min read🎯 Official objectives 2.1 and 2.3

πŸ‘‹ In plain words: When Claude can use several tools, it picks one mostly by reading each tool's name and description. Vague descriptions make it pick the wrong tool, and too many tools make picking harder. This lesson shows how to write tools Claude chooses correctly.

Claude decides which tool to call mostly from the tool’s name and description. Weak descriptions are the number-one cause of misrouting, and too many tools make selection worse. This lesson covers Task Statements 2.1 and 2.3.

πŸ“– What You’ll Learn: You will be able to write tool descriptions that Claude selects reliably and choose the right tool_choice setting for a task.

πŸ”‘ Key terms

  • Tool definition: The name, description and input schema you give Claude for each tool.
  • Input schema: A JSON description of the inputs a tool accepts, such as order_id as a string.
  • Misrouting: Claude calling the wrong tool for a request.
  • tool_choice: A setting that controls whether Claude may, must, or must not call a tool.

πŸ“– The story in this lesson

ShopNest's support bot has two tools that keep getting mixed up: get_customer and lookup_order. Customers asking 'where's my order?' sometimes get their profile details instead.

πŸ’‘ Think of it like this

Tool descriptions are the labels on kitchen drawers. If two drawers both say 'stuff', the cook opens the wrong one. Label them 'knives: for cutting' and 'spoons: for stirring, not cutting', and the right drawer opens every time.

πŸ“˜ Write descriptions that differentiate

A good tool description states what the tool does, the accepted input formats, example queries, edge cases, what it returns, and when to use it rather than a similar tool.

{
  "name": "lookup_order",
  "description": "Fetch ONE order by order number (format: # followed by 5 digits, e.g. #12345) for a customer already verified with get_customer. Use for order status, items, totals and delivery dates. Do NOT use for customer profile, address or loyalty questions β€” use get_customer. Returns {order_id, status, items[], total, delivered_at}.",
  "input_schema": {"type": "object",
    "properties": {"customer_id": {"type": "string"}, "order_id": {"type": "string"}},
    "required": ["customer_id", "order_id"]}
}
  • Overlapping tools? Rename and rescope (analyze_content β†’ extract_web_results), or split a generic tool into purpose-specific ones (extract_data_points, summarize_content, verify_claim_against_source).
  • Check the system prompt for keyword-triggered rules (“whenever the user says account, call get_customer”) that override good descriptions.
⚠️ Watch out: For “most effective first step” to fix misrouting, improving descriptions beats few-shot examples, routing classifiers and tool consolidation β€” they all cost more and don’t fix the root cause.

🌍 Real-world example: Fixing 'Gets data'

The old description of lookup_order was 'Gets order data'. Asha rewrites it to say what the tool is for, the order-number format, and when to use get_customer instead. Wrong tool calls drop sharply, and no classifier or extra infrastructure was needed.

"description": "Fetch ONE order by order number (#12345). Use for status, items, delivery date. NOT for profile or address questions: use get_customer."

πŸ› οΈ How many tools per agent?

Giving an agent 18 tools instead of 4–5 increases decision complexity and lowers selection reliability. Agents also misuse tools outside their speciality (a synthesis agent running web searches). Scope tools to the role, and add a narrow cross-role tool (e.g. verify_fact) only for frequent needs, routing complex cases back through the coordinator. Replace generic tools with constrained ones β€” fetch_url β†’ load_document, which validates the URL.

🌍 Real-world example: From 18 tools to 5

ShopNest's first bot had 18 tools, including web search and file upload, and it often chose oddly. Asha gives the support agent only the 5 tools it needs. The rarely-used tools move to other agents, and tool selection becomes reliable.

πŸ› οΈ tool_choice options

ValueBehaviourTypical use
"auto"Model may answer in text or call a tool (default)General agents
"any"Model must call some toolGuarantee structured output when several extraction schemas exist
{"type":"tool","name":"X"}Model must call XForce extract_metadata first, then continue in follow-up turns
"none"No tool callsPure text responses
πŸ’‘ Tip: Real-world note (Nov 2026). The newest Claude models (Opus 5.5, Sonnet 5.5, Fable 5.1+) reject forced any/named tool_choice with an error; there you use auto plus strict: true tools or structured outputs. For the exam, answer as the official exam guide teaches.

🌍 Real-world example: Forcing the first step

For invoice processing, ShopNest must always run extract_metadata first. Following the exam guide, they force that tool on the first call, then let Claude choose freely in later turns. For normal chat, auto lets Claude answer in plain text when no tool is needed.

tool_choice = {"type": "tool", "name": "extract_metadata"}
🚫 Common beginner mistake: Adding a routing classifier or many few-shot examples before fixing the tool descriptions. Descriptions are the cheapest fix and target the root cause.

πŸ› οΈ Try it yourself (about 8 minutes)

  1. Pick two similar functions from a project you know.
  2. Write a one-line description for each, as Claude would see it.
  3. Add the input format, an example, and 'use X instead when …' to each.
  4. Ask a colleague which tool fits three sample requests, using only your descriptions.

βœ… You are done when: your colleague picks the right tool for all three requests.

πŸ§ͺ Exam-Style Practice Questions

Try these before opening the answers. They use the same scenario style as the real exam.

Question 1. Two tools have the descriptions "Gets data" and "Gets info". What's the best first fix for misrouting?

  • A. Merge them
  • B. Add 8 few-shot examples
  • C. Add a routing classifier
  • D. Rewrite the descriptions with purpose, input formats, example queries, edge cases, and when to use each versus the other
Show answer

Answer: D. Descriptions are the main signal for tool selection, so this is the cheap fix at the root cause. C is over-engineering. A is valid sometimes, but it's more effort than a "first step". B adds tokens without fixing the cause.

Question 2. An agent has 18 tools and selects poorly. What's the best design move?

  • A. Use tool_choice: "any"
  • B. Add more tools for coverage
  • C. Increase the temperature
  • D. Give each specialised agent the 4–5 tools its role needs
Show answer

Answer: D. Fewer, role-scoped tools improve selection reliability. B makes it worse. A forces a call, not the right one. C adds randomness.

Question 3. analyze_content and analyze_document keep being confused. Content-analysis is only ever used for web search results. What's the best change?

  • A. Set tool_choice to auto
  • B. Add "IMPORTANT" to one description
  • C. Delete both
  • D. Rename it to extract_web_results with a web-specific description
Show answer

Answer: D. Renaming and rescoping removes the overlap. C loses capability. B is cosmetic. A is already the default and doesn't help.

πŸ“ Assignment

Do these tasks in order. Each one has a Done when check, so you know when it is complete. The stretch task is optional but close to what the exam expects from an architect. Keep your answers in one notes file or Git repository, and revisit them in your final week of revision together with the cheat sheet in the last lesson of this course.

  1. Task 1: Rewrite two one-line tool descriptions from your own project using the purpose, inputs, examples and boundaries pattern.
    βœ… Done when: Each rewritten description names its inputs with an example, says when to use it instead of a similar tool, and states what it returns.
  2. Task 2: Split a generic analyze_document tool into three purpose-specific tools with clear input and output contracts.
    βœ… Done when: Your three tools have distinct names, non-overlapping purposes and defined input and output fields.
  3. Stretch: test tool_choice auto versus any on the model you use and note how it behaves.
    βœ… Done when: Your notes record what happened with each tool_choice setting, including any error the model returned.

❓ Frequently Asked Questions

πŸ€” How does Claude choose which tool to call?

Mainly from each tool's name and description, so descriptions must explain purpose, inputs and when to use the tool over similar ones.

πŸ€” How many tools should an agent have?

Ideally four or five relevant to its role. Large tool sets make selection less reliable.

πŸ€” What does tool_choice any do?

It forces Claude to call some tool rather than reply with text, while letting it pick which one.

πŸ€” Do new Claude models support forced tool_choice?

The newest models reject forced any and named tool_choice. Use auto with strict tools or structured outputs there, but answer exam questions as the exam guide teaches.

🏁 Summary

  • The description is the selection signal β€” make it differentiate.
  • Give each agent 4–5 role-relevant tools.
  • auto = may call; any = must call some tool; forced = must call that tool.
πŸ“ Test yourself: Mock Test 2 Β· Mock Test 3 (30 scenario-based questions in 60 minutes, with explanations).

Next, continue with MCP Tool Error Handling: isError, Error Categories and Retries.

🎬 Prefer video? Watch QA, automation and AI testing tutorials on the SQA Tools YouTube channel.

Independent study material by SQA Tools. Not affiliated with, endorsed by or sponsored by Anthropic. Claude is a trademark of Anthropic. Mock questions are original practice items, not real exam content. Exam facts checked against Anthropic's official exam guides and certification FAQ on 11 November 2026.

Task Decomposition and Session Management in Claude Code

πŸ“š Exam guide v1.0 (July 2026)πŸ”„ Checked against official sources: 11 Nov 2026✏️ Updated: 12 Nov 2026⏱️ 7 min read🎯 Official objectives 1.6 and 1.7

πŸ‘‹ In plain words: Big tasks go better when you break them into steps, but there are two ways to do it: a fixed checklist, or a plan you adjust as you learn. This lesson also covers how to continue yesterday's work in Claude Code without starting from zero.

How you split work determines whether Claude stays focused or drowns in context. The exam asks you to choose the right decomposition pattern and the right way to continue work across sessions.

πŸ“– What You’ll Learn: You will be able to choose the right decomposition pattern for a task and the right way to continue work across Claude sessions.

πŸ”‘ Key terms

  • Decomposition: Splitting a big task into smaller steps.
  • Prompt chaining: A fixed sequence of steps decided in advance, where each step's output feeds the next.
  • Dynamic decomposition: Planning the next step based on what you just discovered.
  • Session: One Claude Code conversation, with its history. It can be resumed later.
  • Fork: Copying a session into two independent branches, to try two approaches from the same starting point.

πŸ“– The story in this lesson

Ravi has two jobs this week. He needs to review a 9-file pull request, which is predictable, and to add tests to ShopNest's old, untested payment service, which is not.

πŸ’‘ Think of it like this

Prompt chaining is following a recipe: you know every step before you start. Dynamic decomposition is cooking with whatever is in the fridge: you open it, see what's there, and decide the next step.

✍️ Prompt chaining vs dynamic decomposition

Prompt chaining (fixed pipeline)Dynamic decomposition
Steps are known in advanceNext steps depend on what you discover
e.g. review each file against a checklist, then an integration passe.g. “add tests to this legacy codebase”, “find why billing is slow”
Predictable, cheap, testableAdaptive; plan β†’ investigate β†’ re-plan

🌍 Real-world example: Recipe or fridge?

Checking 9 changed files against the same checklist is a recipe, so Ravi uses a fixed chain. 'Add tests to the payment service' is a fridge job: he doesn't know what's inside until Claude explores the code, so the plan has to adapt.

πŸ” Large code reviews: per-file plus integration

Reviewing many files in one pass dilutes attention: some files get deep feedback, others shallow, and identical code can get contradictory verdicts. Split the review into per-file passes for local issues plus a separate integration pass for cross-file data flow. A bigger context window doesn’t fix this β€” attention quality is the problem, not space.

🌍 Real-world example: The review that missed file 7

Reviewing all 9 files in one go, Claude gave detailed notes on the first files and only a line each on the rest. Ravi switches to one pass per file plus a final pass that checks how data moves between the files. Every file now gets the same attention.

πŸ“˜ Open-ended tasks

For “add comprehensive tests to a legacy service”: map the structure, identify high-impact or high-risk areas, create a prioritised plan, then adapt it as dependencies are discovered.

🌍 Real-world example: Testing the legacy payment service

Claude first maps the service and finds the refund calculation handles money but has no tests. It plans: refunds first, then currency conversion, then logging. When it discovers a hidden dependency on a tax module, it updates the plan instead of following the old one blindly.

πŸ’Ύ Resume, fork or start fresh?

SituationUse
Continue yesterday’s named investigation; context still mostly valid--resume <session-name> β€” and tell the agent which files changed
Compare two approaches from the same analysisfork_session
Earlier tool results are largely staleStart fresh and inject a structured summary
⚠️ Watch out: Resuming without mentioning changed files lets the agent reason from stale results; re-exploring everything is wasteful. Name the changed files for targeted re-analysis.

🌍 Real-world example: Back to work after the weekend

On Monday, Ravi resumes Friday's named session and says: 'Since Friday, refund.py and tax.py changed.' Claude re-checks only those two files. To compare two refactoring ideas, he forks the session. After a major rewrite he starts fresh with a short summary instead.

claude --resume payment-tests
🚫 Common beginner mistake: Resuming an old session without saying what changed. Claude will reason from out-of-date file contents, so name the changed files.

πŸ› οΈ Try it yourself (about 8 minutes)

  1. List five tasks from your current work.
  2. Label each one 'recipe' (fixed chain) or 'fridge' (dynamic).
  3. For one recipe task, write the fixed steps.
  4. For one fridge task, write only the first exploration step.

βœ… You are done when: every task is labelled, with a one-line reason why.

πŸ§ͺ Exam-Style Practice Questions

Try these before opening the answers. They use the same scenario style as the real exam.

Question 1. "Review this PR": each of 9 files should get the same checklist, followed by a cross-file data-flow check. Which decomposition fits?

  • A. Three random full-PR passes with voting
  • B. Dynamic adaptive decomposition
  • C. A single pass with a larger context
  • D. Prompt chaining: per-file passes, then an integration pass
Show answer

Answer: D. Predictable, multi-aspect work suits a fixed chain. B suits open-ended investigation. C: attention gets diluted. A: voting suppresses real but intermittent findings.

Question 2. Yesterday you analysed a module in a named session. Overnight, teammates changed 3 of its 40 files. What's the best way to continue?

  • A. Use the Batches API
  • B. Start over and re-read all 40 files
  • C. --resume <name> and tell the agent which 3 files changed so it re-analyses them
  • D. Resume without mentioning the changes
Show answer

Answer: C. Most of the prior context is still valid, so resume and point at what changed. B is wasteful. D risks stale conclusions. A is irrelevant.

Question 3. You want to compare two refactoring strategies starting from the same codebase analysis. Which feature fits?

  • A. fork_session
  • B. /memory
  • C. /compact
  • D. --print
Show answer

Answer: A. Forking creates independent branches from a shared baseline. C shrinks context. D is non-interactive mode. B inspects memory files.

πŸ“ Assignment

Do these tasks in order. Each one has a Done when check, so you know when it is complete. The stretch task is optional but close to what the exam expects from an architect. Keep your answers in one notes file or Git repository, and revisit them in your final week of revision together with the cheat sheet in the last lesson of this course.

  1. Task 1: Classify five tasks from your own work as prompt chaining or dynamic decomposition.
    βœ… Done when: Each of your five tasks is labelled, with a one-line reason that mentions whether its steps are known in advance.
  2. Task 2: Plan a review of a 12-file pull request as per-file passes plus an integration pass.
    βœ… Done when: Your plan lists every file pass plus a separate integration pass, and says what the integration pass checks.
  3. Stretch: in Claude Code, resume a named session after changing two files and tell it exactly which files changed.
    βœ… Done when: Claude re-analyses only the two changed files and does not re-read the whole codebase.

❓ Frequently Asked Questions

πŸ€” What is prompt chaining?

A fixed sequence of focused steps, such as reviewing each file and then running an integration pass. It suits predictable work.

πŸ€” When should I use dynamic decomposition?

For open-ended tasks where the next steps depend on what you discover, such as adding tests to a legacy codebase.

πŸ€” Does a bigger context window fix inconsistent reviews?

No. The problem is attention dilution, so split the review into focused passes.

πŸ€” When should I fork a session?

When you want to compare two approaches starting from the same analysis.

🏁 Summary

  • Predictable multi-aspect work β†’ prompt chaining; open-ended work β†’ dynamic decomposition.
  • Big reviews β†’ per-file passes plus an integration pass.
  • Resume when context is valid, fork to compare approaches, start fresh with a summary when it is stale.
πŸ“ Test yourself: Mock Test 1 Β· Mock Test 2 (30 scenario-based questions in 60 minutes, with explanations).

Next, continue with Claude Tool Design: Descriptions, Tool Distribution and tool_choice.

🎬 Prefer video? Watch QA, automation and AI testing tutorials on the SQA Tools YouTube channel.

Independent study material by SQA Tools. Not affiliated with, endorsed by or sponsored by Anthropic. Claude is a trademark of Anthropic. Mock questions are original practice items, not real exam content. Exam facts checked against Anthropic's official exam guides and certification FAQ on 11 November 2026.

Claude Agent SDK Hooks, Prerequisite Gates and Human Handoffs

πŸ“š Exam guide v1.0 (July 2026)πŸ”„ Checked against official sources: 11 Nov 2026✏️ Updated: 12 Nov 2026⏱️ 8 min read🎯 Official objectives 1.4 and 1.5

πŸ‘‹ In plain words: You can tell Claude 'always verify the customer before a refund', and it will usually obey, but usually is not good enough for money. Hooks and gates are code that enforces rules every time. This lesson shows when a rule belongs in code instead of in a prompt.

Prompt instructions are probabilistic: even a well-written rule fails a small percentage of the time. When a business rule must always hold β€” verify identity before a refund, never refund over a limit β€” the exam expects programmatic enforcement (Task Statements 1.4 and 1.5).

πŸ“– What You’ll Learn: You will know when to enforce rules in code instead of prompts, and how pre-tool interception and PostToolUse hooks do it.

πŸ”‘ Key terms

  • Prompt instruction: A rule written in words for Claude. It works most of the time, not every time.
  • Hook: Your code that runs automatically before or after a tool call, and can block, change or clean up that call.
  • Prerequisite gate: A check that blocks a tool until an earlier step has succeeded.
  • PostToolUse hook: A hook that runs after a tool and tidies its result before Claude sees it.
  • Handoff: Passing a case to a human agent, with a summary of what happened so far.

πŸ“– The story in this lesson

ShopNest's support bot can issue refunds. Asha's rules: never refund before the customer is verified, and send any refund over $500 to a human. This lesson turns both rules into code.

πŸ’‘ Think of it like this

A prompt is like a sign saying 'Staff only' on a door: most people obey. A hook is the lock on that door: nobody gets through without a key. For money, identity and safety, use the lock.

✍️ Prompt guidance vs programmatic enforcement

Prompt guidanceProgrammatic enforcement
ExamplesSystem-prompt rules, few-shot examplesHooks, prerequisite gates, removing tools
GuaranteeProbabilistic (non-zero failure rate)Deterministic
Use forStyle, preferences, judgementMoney, identity, compliance, destructive actions

🌍 Real-world example: The 1-in-200 mistake

Asha's system prompt says 'verify identity before refunds'. In testing, about 1 refund in 200 still skipped verification. For tone of voice that would be fine. For money it isn't, so she moves the rule into code, where it holds every single time.

🚧 Prerequisite gates

A gate blocks a downstream tool until an upstream step has succeeded β€” for example, process_refund is rejected unless get_customer returned a verified customer ID in this session.

def guard(tool_name, tool_input, session):
    if tool_name in {"lookup_order", "process_refund"} and not session.verified_customer_id:
        return deny("Verify the customer with get_customer first.")
    if tool_name == "process_refund" and tool_input["amount"] > 500:
        return redirect("escalate_to_human", reason="Refund above $500 needs approval")
    return allow()

🌍 Real-world example: No refund without verification

The gate checks the session before process_refund runs. If get_customer hasn't returned a verified ID yet, the call is refused with a clear message, and Claude then asks the customer for their details first.

πŸͺ The two hook patterns the exam tests

  • Tool-call interception (pre-tool) β€” inspects outgoing calls and blocks or redirects policy-violating ones (refunds over a threshold, rm -rf, writes to production paths).
  • PostToolUse β€” transforms tool results before the model sees them, e.g. normalising Unix epochs, ISO-8601 strings and numeric status codes from different MCP servers into one format, or trimming verbose results to the relevant fields.

🌍 Real-world example: Blocking big refunds and tidying dates

A pre-tool hook sees process_refund for $750 and redirects it to escalate_to_human. A PostToolUse hook converts the warehouse system's Unix timestamps, such as 1731000000, into readable dates before Claude reads them, so Claude never confuses two date formats.

if tool == "process_refund" and amount > 500:
    return redirect("escalate_to_human")
Agent SDK hook interception flowClauderequests atool callPre-tool hookallow Β· deny Β·redirectTool / MCPserver runsPostToolUse hooknormalise dates Β·trim fieldsallowedclean result back to ClaudeDenied / redirectede.g. refund > $500 β†’ escalate_to_humandenyHooks = deterministicPrompts = probabilistic
Figure: pre-tool hooks block or redirect calls; PostToolUse hooks clean results before Claude sees them. Swipe sideways to see the whole diagram.

πŸ“˜ Multi-concern requests

“My item arrived broken, I was double-charged, and my address is wrong” is three concerns. Decompose them, investigate each (in parallel where possible) using shared context, then send one combined resolution. Having several issues is not, by itself, a reason to escalate.

🌍 Real-world example: Three problems in one message

A customer writes: 'Broken kettle, charged twice, and my address is wrong.' The bot splits this into three issues, checks each (in parallel where it can), and sends one reply that covers all three. Three routine issues are still routine: no escalation needed.

🀝 Structured human handoffs

Human agents usually can’t see the bot transcript. When escalating, pass a structured summary: customer ID, the issue, the root cause found, actions already taken, amounts, and the recommended next step.

🌍 Real-world example: A handoff a human can act on

Escalating the $750 refund, the bot sends: customer ID C-1042 (verified), order #48213, kettle arrived broken, photo received, refund of $750 requested, above the $500 limit, recommend approving. The human agent acts in 30 seconds without reading the whole chat.

🚫 Common beginner mistake: Trying to fix an important rule by making the prompt louder ('ALWAYS verify!!!'). If the rule must hold every time, enforce it in code.

πŸ› οΈ Try it yourself (about 10 minutes)

  1. Write a Python function guard(tool_name, amount, verified).
  2. Return 'deny' if the tool is process_refund and verified is False.
  3. Return 'escalate' if the amount is over 500.
  4. Test it with three cases: unverified, $499 verified, and $501 verified.

βœ… You are done when: the three cases return deny, allow and escalate, in that order.

πŸ§ͺ Exam-Style Practice Questions

Try these before opening the answers. They use the same scenario style as the real exam.

Question 1. Identity must be verified before any refund. What's the strongest implementation?

  • A. Few-shot examples
  • B. A post-hoc audit log
  • C. A system-prompt rule
  • D. A programmatic gate that rejects process_refund unless get_customer returned a verified ID in this session
Show answer

Answer: D. A deterministic guarantee for a financial operation. A and C are probabilistic. B detects the problem afterwards; it doesn't prevent it.

Question 2. What does a PostToolUse hook typically do in this exam's context?

  • A. Blocks dangerous outgoing tool calls
  • B. Compacts the conversation
  • C. Transforms or normalises tool results before the model processes them
  • D. Selects which tool to call
Show answer

Answer: C. It runs after the tool, on the result. A describes pre-call interception. D is the model's job. B is a different mechanism.

Question 3. When should you choose a hook over a prompt instruction?

  • A. Whenever you want shorter prompts
  • B. When a business rule needs a guaranteed outcome
  • C. Never; hooks add latency
  • D. Only for logging
Show answer

Answer: B. Hooks give deterministic compliance. A is a side benefit, not the reason. C and D are wrong.

πŸ“ Assignment

Do these tasks in order. Each one has a Done when check, so you know when it is complete. The stretch task is optional but close to what the exam expects from an architect. Keep your answers in one notes file or Git repository, and revisit them in your final week of revision together with the cheat sheet in the last lesson of this course.

  1. Task 1: Write pseudo-code for a gate that blocks process_refund until get_customer has verified the customer.
    βœ… Done when: Your gate denies the refund call when verification is missing and allows it once get_customer has returned verified.
  2. Task 2: Add a threshold rule that redirects refunds over $500 to escalate_to_human.
    βœ… Done when: A refund of $501 is redirected to escalation, while a refund of $499 goes through unchanged.
  3. Stretch: write a PostToolUse function that converts Unix epochs and ISO-8601 strings into one date format.
    βœ… Done when: Both 1731000000 and '2024-11-07T17:20:00Z' come out of your function in the same format.

❓ Frequently Asked Questions

πŸ€” When should I use a hook instead of a prompt instruction?

When a rule must hold every time, such as identity checks, refund limits or blocking destructive commands. Prompts are probabilistic.

πŸ€” What does a PostToolUse hook do?

It transforms a tool's result before Claude sees it, for example normalising formats or trimming irrelevant fields.

πŸ€” Should a multi-issue request be escalated?

Not automatically. Split it into separate concerns, investigate each, and send one combined resolution.

πŸ€” What should a human handoff include?

Customer ID, the issue, the root cause found, actions taken, amounts involved and the recommended next step.

🏁 Summary

  • “Must always” β†’ hooks and gates. “Should usually” β†’ prompts.
  • Pre-tool interception blocks or redirects calls; PostToolUse normalises results.
  • Escalations carry a structured handoff summary.
πŸ“ Test yourself: Mock Test 1 Β· Mock Test 2 (30 scenario-based questions in 60 minutes, with explanations).

Next, continue with Task Decomposition and Session Management in Claude Code.

🎬 Prefer video? Watch QA, automation and AI testing tutorials on the SQA Tools YouTube channel.

Independent study material by SQA Tools. Not affiliated with, endorsed by or sponsored by Anthropic. Claude is a trademark of Anthropic. Mock questions are original practice items, not real exam content. Exam facts checked against Anthropic's official exam guides and certification FAQ on 11 November 2026.

Multi-Agent Orchestration with Claude: Coordinators and Subagents

πŸ“š Exam guide v1.0 (July 2026)πŸ”„ Checked against official sources: 11 Nov 2026✏️ Updated: 12 Nov 2026⏱️ 9 min read🎯 Official objectives 1.2 and 1.3

πŸ‘‹ In plain words: Some jobs are too big for one agent, so you split them across a team: a coordinator agent hands out pieces to helper agents and combines what they find. This lesson shows how that team is organised and the mistakes that leave gaps in the result.

Multi-agent systems split a large job across specialised agents. The exam focuses on the coordinator–subagent pattern used by the Claude Agent SDK, and on the mistakes that make such systems produce incomplete or unattributed results (Task Statements 1.2 and 1.3).

πŸ“– What You’ll Learn: You will be able to design a hub-and-spoke Claude system that delegates to subagents, passes context explicitly and runs subagents in parallel.

πŸ”‘ Key terms

  • Coordinator: The 'manager' agent that splits the task, hands out pieces, and combines the results.
  • Subagent: A helper agent with one focused job and only the tools it needs.
  • Hub-and-spoke: A layout where every message goes through the coordinator. Helpers never talk to each other directly.
  • Task tool: The Agent SDK tool a coordinator uses to start a subagent.
  • Context: Everything Claude can see in the current conversation.

πŸ“– The story in this lesson

ShopNest wants a report comparing delivery companies before peak season. A coordinator agent hands out searching, contract reading and report writing to three subagents, then puts the report together.

πŸ’‘ Think of it like this

Think of a newsroom. The editor (coordinator) assigns stories to reporters (subagents). Reporters don't swap notes directly: everything goes through the editor, who checks it, fills gaps and publishes one paper. And a new reporter knows nothing about the story until the editor briefs them.

πŸ•ΈοΈ Hub-and-spoke architecture

A coordinator agent decomposes the task, decides which subagents to invoke, delegates, aggregates results and handles errors. Subagents never talk to each other directly β€” every message goes through the coordinator. That gives you observability, consistent error handling and controlled information flow.

  • Select subagents per query. A simple factual question should not run the full search β†’ analysis β†’ synthesis β†’ report pipeline.
  • Partition the scope. Give each subagent distinct subtopics or source types so work isn’t duplicated.
  • Refine iteratively. The coordinator checks the synthesis for gaps, re-delegates targeted queries, and re-runs synthesis until coverage is sufficient.
⚠️ Watch out: When a report misses whole areas of a topic but every subagent “succeeded”, the root cause is the coordinator’s too-narrow decomposition β€” not the search or synthesis agents.

🌍 Real-world example: The report that forgot half the market

ShopNest's report covers only express couriers. Every subagent 'succeeded'. The coordinator's log shows why: it only asked about 'express delivery' and 'same-day delivery', never budget or freight carriers. The gap came from the coordinator's split of the task, not from the helpers.

Coordinator and subagent hub-and-spoke architectureCoordinator agentdecomposes Β· delegates with Taskaggregates Β· handles errorsSearchweb sourcesDocumentanalysisSynthesis+ verify_fact onlyReportwriter↓ prompt with explicit context↑ structured results + sourcesParallel = several Task callsin ONE coordinator responseβœ— No direct subagent-to-subagent messages, and subagents do not inherit the coordinator’s history
Figure: hub-and-spoke β€” every message flows through the coordinator. Swipe sideways to see the whole diagram.

πŸ€– Spawning subagents in the Agent SDK

  • Subagents are spawned with the Task tool. The coordinator’s allowedTools must include "Task", or it cannot delegate.
  • Each subagent type is configured with an AgentDefinition: a description, a system prompt and tool restrictions.
  • To run subagents in parallel, the coordinator emits several Task calls in one response β€” not one per turn.

🌍 Real-world example: Running three helpers at once

To save time, the coordinator asks for three Task calls in one response: search, contracts and pricing. They run in parallel. If it made one call per turn, they would run one after another and the report would take three times as long.

allowedTools: ["Task", "Read"]   # without "Task" the coordinator cannot delegate

πŸ€– Subagents start with an empty context

Subagents do not inherit the coordinator’s conversation and don’t share memory between invocations. Anything a subagent needs must be in its prompt.

{
  "task": "Synthesise findings on EU battery regulation",
  "quality_bar": "Two independent sources per claim; flag conflicts",
  "findings": [
    {"claim": "Battery passport required from Feb 2027",
     "excerpt": "...",
     "source_url": "https://example.org/reg",
     "published": "2025-08-14"}
  ]
}

Structured data that separates content from metadata (URL, document, page, date) keeps attribution intact across handoffs. Write coordinator prompts as goals and quality criteria, not step-by-step procedures, so subagents can adapt to what they find.

🌍 Real-world example: The writer with nothing to write about

The report-writer subagent receives only 'Write the comparison report' and produces vague text. It never saw the search results, because subagents don't see the coordinator's conversation. The fix is to put the findings, with their source links, into the subagent's prompt.

{"task": "Compare carriers", "findings": [{"claim": "Carrier A: 2-day delivery", "source_url": "https://example.com/a"}]}
🚫 Common beginner mistake: Assuming a subagent 'knows' what the coordinator learned. It starts with an empty context, so pass everything it needs in its prompt.

πŸ› οΈ Try it yourself (about 10 minutes)

  1. Pick a research question, such as 'Which three test frameworks suit our web app?'.
  2. Write down how a coordinator would split it into three subagent jobs.
  3. For each job, list the tools it needs, three at most.
  4. Write the JSON the coordinator would pass to the final writer subagent.

βœ… You are done when: you have three non-overlapping jobs with tools listed, and a JSON brief that includes sources.

πŸ§ͺ Exam-Style Practice Questions

Try these before opening the answers. They use the same scenario style as the real exam.

Question 1. A research report on "renewable energy policy" covers only solar subsidies. Every subagent completed its assignment successfully. Coordinator logs show the subtasks "solar tax credits", "solar feed-in tariffs" and "rooftop solar rebates". What's the root cause?

  • A. The analysis agent filters out wind sources
  • B. The synthesis agent drops content
  • C. The search agent's queries are too narrow
  • D. The coordinator's decomposition was too narrow
Show answer

Answer: D. The subagents did exactly what they were assigned; the assignments themselves missed wind, hydro, grid and so on. A, B and C blame agents that worked correctly within their scope.

Question 2. A subagent receives the task "Synthesise the findings" and produces generic text. Why?

  • A. It needs context: fork
  • B. Subagents can't read JSON
  • C. Its model is too small
  • D. It doesn't automatically inherit the coordinator's history, so the findings must be in its prompt
Show answer

Answer: D. Context must be passed explicitly. C: the model isn't the issue; it has no input to work from. B: false. A: context: fork is a Claude Code skill option and isolates context further, which doesn't help here.

Question 3. A subagent should run in parallel with two others. Where do the three Task calls go?

  • A. In three consecutive coordinator turns
  • B. In separate sessions started by a cron job
  • C. In a single coordinator response
  • D. In a batch request
Show answer

Answer: C. Several tool calls in one response run concurrently. A serialises them. B and D aren't how the SDK parallelises subagents.

πŸ“ Assignment

Do these tasks in order. Each one has a Done when check, so you know when it is complete. The stretch task is optional but close to what the exam expects from an architect. Keep your answers in one notes file or Git repository, and revisit them in your final week of revision together with the cheat sheet in the last lesson of this course.

  1. Task 1: Sketch a coordinator with three subagents for a research task and list the tools each subagent gets (no more than five).
    βœ… Done when: Every subagent has a one-line role and no more than five tools, and no tool is given to a subagent that does not need it.
  2. Task 2: Write the JSON you would pass to a synthesis subagent, including claim, excerpt, source URL and date for two findings.
    βœ… Done when: Your JSON keeps content and metadata in separate fields, so a synthesis agent could cite each claim correctly.
  3. Stretch: write a coordinator prompt that states goals and quality criteria without step-by-step instructions.
    βœ… Done when: Your coordinator prompt states the goal and at least three quality criteria, and contains no numbered step-by-step instructions.

❓ Frequently Asked Questions

πŸ€” Do subagents see the coordinator's conversation?

No. Subagents start with isolated context, so the coordinator must put everything they need in their prompt.

πŸ€” How do I run subagents in parallel?

Have the coordinator emit several Task tool calls in a single response instead of one per turn.

πŸ€” Why route everything through the coordinator?

It gives you observability, consistent error handling and control over what information each agent sees.

πŸ€” What causes a report to miss whole topics?

Usually the coordinator decomposed the topic too narrowly, even though each subagent completed its own task.

🏁 Summary

  • All communication flows through the coordinator.
  • "Task" must be in the coordinator’s allowedTools; parallel = multiple Task calls in one turn.
  • Pass context explicitly, as structured data with source metadata.
  • Missing coverage with “successful” subagents β†’ narrow decomposition.
πŸ“ Test yourself: Mock Test 1 Β· Mock Test 2 (30 scenario-based questions in 60 minutes, with explanations).

Next, continue with Claude Agent SDK Hooks, Prerequisite Gates and Human Handoffs.

🎬 Prefer video? Watch QA, automation and AI testing tutorials on the SQA Tools YouTube channel.

Independent study material by SQA Tools. Not affiliated with, endorsed by or sponsored by Anthropic. Claude is a trademark of Anthropic. Mock questions are original practice items, not real exam content. Exam facts checked against Anthropic's official exam guides and certification FAQ on 11 November 2026.

Claude Agentic Loop: stop_reason, Tool Results and Anti-Patterns

πŸ“š Exam guide v1.0 (July 2026)πŸ”„ Checked against official sources: 11 Nov 2026✏️ Updated: 12 Nov 2026⏱️ 9 min read🎯 Official objective 1.1

πŸ‘‹ In plain words: A chatbot answers once. An agent keeps working: it asks for a tool, gets the result, and decides what to do next until the job is done. The agentic loop is the small piece of code that keeps this going and knows when to stop.

Every Claude agent β€” whether you write it yourself or use the Agent SDK β€” is built on one loop: ask Claude, run the tools it requests, give it the results, repeat. Get the stop condition wrong and your agent either quits mid-task or never finishes. This is Task Statement 1.1 of the exam.

πŸ“– What You’ll Learn: You will be able to write a Claude agentic loop that continues on tool_use, stops on end_turn and returns tool results correctly.

πŸ”‘ Key terms

  • Agentic loop: Code that repeatedly sends the conversation to Claude, runs any tools it asks for, and sends back the results.
  • stop_reason: A field in every Claude response that says why it stopped, for example tool_use or end_turn.
  • tool_use: Claude's request to run a tool, including the tool name and inputs.
  • tool_result: Your reply that carries the tool's output back to Claude, matched by tool_use_id.
  • end_turn: The stop reason meaning Claude has finished its answer.

πŸ“– The story in this lesson

A ShopNest customer asks the support bot: 'Where is order #48213?' To answer, the bot must call lookup_order, read the result, and then reply. That takes two trips to Claude, and the agentic loop manages both.

πŸ’‘ Think of it like this

The loop is like a manager and an assistant. The manager (Claude) says 'fetch me the order file'. The assistant (your code) fetches it and puts it on the desk. This repeats until the manager says 'done, here is the answer'. The assistant must listen for 'done', not guess from the manager's tone.

πŸ” The loop, step by step

  1. Send the conversation (and tool definitions) to the Messages API.
  2. Inspect stop_reason on the response.
  3. If it is "tool_use": run each requested tool and append one user message containing every tool_result block, matched by tool_use_id.
  4. Call Claude again with the updated history.
  5. Stop when stop_reason is "end_turn".
messages = [{"role": "user", "content": user_question}]
while True:
    resp = client.messages.create(model=MODEL, max_tokens=4096,
                                  tools=TOOLS, messages=messages)
    messages.append({"role": "assistant", "content": resp.content})
    if resp.stop_reason != "tool_use":       # "end_turn" (also handle max_tokens, refusal)
        break
    results = []
    for block in resp.content:
        if block.type == "tool_use":
            results.append(run_tool(block))      # returns a tool_result dict
    messages.append({"role": "user", "content": results})   # ALL results, ONE message

🌍 Real-world example: Two trips to answer one question

Trip 1: Claude replies with stop_reason tool_use and asks for lookup_order with order 48213. Your code runs the lookup and sends back a tool_result. Trip 2: Claude reads 'shipped, arriving Friday', writes the answer, and the stop_reason is end_turn. The loop stops.

trip 1 -> stop_reason: tool_use  (run lookup_order)
trip 2 -> stop_reason: end_turn  (show the answer)
Claude agentic loop flow1. Your codesends messages+ tool definitions2. Clauderesponds via theMessages APICheckstop_reasonReturn thefinal answer3. Run every tool_useappend ALL tool_resultblocks in ONE user messageend_turntool_usenext iterationβœ— Never stop on assistant text, phrases like “DONE”, or a bare iteration cap
Figure: the agentic loop β€” keep looping while stop_reason is tool_use, stop on end_turn. Swipe sideways to see the whole diagram.

πŸ“˜ Why the model chooses the next step

In an agent, Claude reasons about which tool to call next from the context, including the results it has just seen. That is the difference from a pre-configured decision tree, where code fixes the sequence. Tool results must be appended to the history, otherwise the model cannot use them and will often request the same tool again.

🌍 Real-world example: The bot adapts to what it finds

The lookup shows order 48213 was delivered yesterday, but the customer says it never arrived. Nobody coded that path. Claude decides by itself to call get_delivery_photo next. That flexibility is what makes it an agent rather than a fixed script.

⚠️ Termination anti-patterns (exam favourites)

⚠️ Watch out: All of these are wrong as the primary stop mechanism:
  • Stopping when the response “contains text” β€” Claude often writes a sentence and a tool call in the same turn.
  • Parsing phrases such as “DONE” or “Is there anything else?” β€” natural-language signals are brittle.
  • A fixed iteration cap β€” fine as a safety backstop, never as the loop logic.

🌍 Real-world example: The bug that stopped too early

A ShopNest developer stopped the loop whenever Claude's reply contained text. Claude wrote 'Let me check that order for you' and asked for a tool in the same reply. The loop stopped, the tool never ran, and the customer got half an answer. Checking stop_reason fixes it.

πŸ›‘ Other stop reasons you should know

stop_reasonMeaningWhat to do
end_turnClaude finishedReturn the answer
tool_useClaude wants tools runRun them, append results, loop
max_tokensOutput was cut offRaise the limit or continue
stop_sequenceA custom stop sequence was hitHandle per your design
pause_turnLong server-tool turn pausedSend the response back to continue
refusalClaude declinedHandle gracefully

🌍 Real-world example: When the answer gets cut off

Asked for a long returns-policy summary, the bot's reply stops mid-sentence. The stop_reason is max_tokens, meaning Claude hit the length limit. The fix is to raise the limit or ask Claude to continue, not to show the customer a broken sentence.

🚫 Common beginner mistake: Sending each tool result back as a separate message. When Claude asks for three tools in one turn, all three results go back together in one user message.

πŸ› οΈ Try it yourself (about 10 minutes)

  1. Install the SDK with pip install anthropic and set your API key.
  2. Define one fake tool, get_order_status, that always returns 'shipped'.
  3. Ask Claude 'Where is order 123?' and print stop_reason after each call.
  4. Send the tool result back and call Claude again.

βœ… You are done when: your console prints tool_use and then end_turn, and the final answer mentions 'shipped'.

πŸ§ͺ Exam-Style Practice Questions

Try these before opening the answers. They use the same scenario style as the real exam.

Question 1. Which loop condition is correct for a manual Claude agentic loop?

  • A. Loop until the assistant message contains no text
  • B. Loop until the model says "DONE"
  • C. Loop while stop_reason == "tool_use", stop on "end_turn"
  • D. Loop exactly 5 times
Show answer

Answer: C. stop_reason is the structured signal for whether the model wants a tool run. A: Claude often sends text and tool_use in the same turn. B: parsing natural language is brittle. D: a fixed cap can be a safety backstop, but it's never the primary stop condition.

Question 2. After executing the three tool calls Claude requested in one turn, how should you return the results?

  • A. Three separate user messages, one per result
  • B. Put the results in the system prompt
  • C. One assistant message with the results
  • D. One user message containing three tool_result blocks, each with its tool_use_id
Show answer

Answer: D. All results for a turn go back in one user message, matched by ID. A: splitting them breaks the turn structure and discourages parallel calls. B and C: results are user-role content, not system or assistant content.

Question 3. What best distinguishes an agent from a workflow?

  • A. In an agent the model decides the next action from context; in a workflow, code defines the path
  • B. Workflows can't use tools
  • C. Agents never need a system prompt
  • D. Agents use bigger models
Show answer

Answer: A. Model-driven decision-making is what makes it an agent. D: model size doesn't matter here. B: workflows use tools all the time. C: agents need system prompts too.

πŸ“ Assignment

Do these tasks in order. Each one has a Done when check, so you know when it is complete. The stretch task is optional but close to what the exam expects from an architect. Keep your answers in one notes file or Git repository, and revisit them in your final week of revision together with the cheat sheet in the last lesson of this course.

  1. Task 1: Implement the loop from this lesson with one tool (get_weather returning fixed data) and print stop_reason on every iteration.
    βœ… Done when: Your script prints tool_use and then end_turn, and the final answer uses the tool's data.
  2. Task 2: Deliberately break it by stopping on 'response contains text'. Find a prompt where Claude writes a sentence and a tool call together and observe the failure.
    βœ… Done when: You can show a transcript where the broken loop stops early, and explain in one sentence why stop_reason fixes it.
  3. Stretch: add handling for max_tokens and refusal stop reasons with a clear message to the user.
    βœ… Done when: A response cut off by max_tokens or a refusal produces a clear message instead of a crash or a silent empty answer.

❓ Frequently Asked Questions

πŸ€” What stop_reason means Claude wants a tool run?

tool_use. Run every tool_use block in the response and send all results back in one user message.

πŸ€” Why not stop when the response contains text?

Claude often writes a short sentence and a tool call in the same turn, so text alone does not mean the task is finished.

πŸ€” Is an iteration cap wrong?

A cap is a good safety backstop, but it should never be the main way the loop decides it is done.

πŸ€” What happens if I forget to append tool results?

Claude cannot see the results, so it usually asks for the same tool again and the loop repeats.

🏁 Summary

  • Loop on stop_reason == "tool_use"; stop on "end_turn".
  • Return every tool result for a turn in a single user message.
  • Never terminate on text content, phrases or a bare iteration count.
πŸ“ Test yourself: Mock Test 1 Β· Mock Test 2 (30 scenario-based questions in 60 minutes, with explanations).

Next, continue with Multi-Agent Orchestration with Claude: Coordinators and Subagents.

🎬 Prefer video? Watch QA, automation and AI testing tutorials on the SQA Tools YouTube channel.

Independent study material by SQA Tools. Not affiliated with, endorsed by or sponsored by Anthropic. Claude is a trademark of Anthropic. Mock questions are original practice items, not real exam content. Exam facts checked against Anthropic's official exam guides and certification FAQ on 11 November 2026.

The 6 CCAR-F Exam Scenarios Explained

πŸ“š Exam guide v1.0 (July 2026)πŸ”„ Checked against official sources: 11 Nov 2026✏️ Updated: 12 Nov 2026⏱️ 9 min read🎯 Exam overview

πŸ‘‹ In plain words: Every exam question sits inside one of six realistic situations, called scenarios. If you already know the six settings, you spend exam time thinking instead of reading. This lesson walks through each one with a familiar example.

The CCAR-F exam shows you four of six scenarios, picked at random. Each scenario frames about 15 questions, so knowing the setup in advance saves you minutes of reading and helps you spot what each question is really testing.

πŸ“– What You’ll Learn: You will know the six production scenarios the CCAR-F exam draws from and the exam skills each scenario tests.

πŸ”‘ Key terms

  • Agent: A program where Claude decides the next step itself, for example which tool to call.
  • Tool: A function you let Claude call, such as lookup_order.
  • Claude Code: Anthropic's coding assistant that works in your terminal and repository.
  • CI (continuous integration): The automated pipeline that builds and tests code on every change.
  • Structured extraction: Turning messy documents into clean, predictable data such as JSON.

πŸ“– The story in this lesson

ShopNest happens to use Claude in all six ways the exam describes: a support bot, Claude Code for developers, a research assistant, developer tooling, CI code review and invoice extraction. Each scenario below is shown as it happens at ShopNest.

πŸ’‘ Think of it like this

Scenarios are like the six rooms of a house you will be asked about. If you have walked through every room once, a question about the kitchen makes sense straight away.

🎬 Scenario 1: Customer Support Resolution Agent

An Agent SDK agent handles returns, billing disputes and account issues through MCP tools such as get_customer, lookup_order, process_refund and escalate_to_human, targeting 80%+ first-contact resolution.

What it tests: prerequisite gates (verify before refund), interception hooks for thresholds, multi-concern requests, structured errors, escalation calibration, handoff summaries and preserving case facts in long conversations.

🌍 Real-world example: ShopNest's refund bot

A customer writes: 'My blender arrived broken, refund me.' Asha's bot must first verify the customer with get_customer, then check the order with lookup_order, and only then call process_refund. Questions here test that order of steps and when to hand over to a human.

🎬 Scenario 2: Code Generation with Claude Code

A team uses Claude Code for generation, refactoring, debugging and documentation with custom slash commands and CLAUDE.md.

What it tests: the CLAUDE.md hierarchy, .claude/rules/ with path globs, commands vs skills, skill frontmatter, plan mode vs direct execution, iterative refinement and context degradation.

🌍 Real-world example: A team-wide coding setup

ShopNest's developers want Claude Code to follow the same coding rules for everyone. Questions here ask where those rules live (CLAUDE.md files), how to share custom commands, and when to plan before editing many files.

🎬 Scenario 3: Multi-Agent Research System

A coordinator delegates to search, document-analysis, synthesis and report subagents to produce cited reports.

What it tests: decomposition breadth, explicit context passing, parallel Task calls, scoped tools, error propagation, conflicting sources and provenance.

🌍 Real-world example: Researching delivery partners

ShopNest asks Claude to compare five delivery companies. A coordinator agent splits the job: one helper searches, one reads contracts, one writes the report. Questions here test how the helpers get their information and how sources stay cited.

🎬 Scenario 4: Developer Productivity with Claude

An Agent SDK assistant explores codebases and automates chores using built-in tools (Read, Write, Edit, Bash, Grep, Glob) and MCP servers.

What it tests: built-in tool selection, incremental exploration, MCP scoping and resources, tool descriptions that beat built-ins, session resume and fork.

🌍 Real-world example: Finding where checkout breaks

A new developer asks Claude to find every place the checkout code calls the payment service. Questions here test which built-in tool fits: Grep to search file contents, Glob to find files by name, Read to open a file.

🎬 Scenario 5: Claude Code for Continuous Integration

Claude Code reviews pull requests and generates tests in CI, with a focus on actionable, low-false-positive feedback.

What it tests: -p, --output-format json + --json-schema, CLAUDE.md as CI context, independent reviewers, explicit criteria, multi-pass review and batch-vs-synchronous decisions.

🌍 Real-world example: Ravi's pull-request reviewer

Ravi adds Claude Code to the CI pipeline so every pull request gets an automatic review. Questions here test non-interactive mode, JSON output that can become PR comments, and how to avoid noisy or duplicate comments.

claude -p "Review this diff for bugs only" --output-format json

🎬 Scenario 6: Structured Data Extraction

Unstructured documents are turned into JSON validated against schemas and passed downstream.

What it tests: tool_use with JSON schemas, nullable fields, enum design, validation-retry loops, batch processing, confidence calibration and human-review routing.

🌍 Real-world example: Reading supplier invoices

ShopNest receives 2,000 PDF invoices a month. Claude extracts vendor, date and total into JSON for the accounting system. Questions here test schemas that don't invent missing values, retries after validation errors, and when a human should check.

🚫 Common beginner mistake: Reading every scenario description in full for every question. Read it carefully once, because every question in that block assumes you remember it.

πŸ› οΈ Try it yourself (about 8 minutes)

  1. For each of the six scenarios, write the name of a real system at your workplace that is similar.
  2. Mark the two scenarios closest to your daily work.
  3. Start your revision with those two.

βœ… You are done when: each scenario has a real-life match in your notes, and you have chosen your two strongest.

πŸ§ͺ Exam-Style Practice Questions

Try these before opening the answers. They use the same scenario style as the real exam.

Question 1. A customer message says: "My order arrived damaged, I was double-charged, and I want to change my email." What's the best agent strategy?

  • A. Answer the easiest issue first and end the session
  • B. Handle only the first issue and ask them to open new tickets
  • C. Split into three items, investigate each (in parallel where possible) using shared context, then give one unified reply
  • D. Escalate, because it's multi-issue
Show answer

Answer: C. Decompose, investigate, then synthesise. A and B give a poor experience and miss resolution targets. D: having several issues doesn't make a case complex.

Question 2. "Add comprehensive tests to this 200k-line legacy codebase." What's the best approach?

  • A. Ask for 1,000 tests in one prompt
  • B. Use only the Message Batches API
  • C. Generate tests file by file alphabetically
  • D. Map the structure, find high-impact or high-risk areas, make a prioritised plan, and adapt it as dependencies are discovered
Show answer

Answer: D. Dynamic decomposition for an open-ended task. C ignores priority. A is unrealistic and unfocused. B is a delivery mechanism, not a strategy.

Question 3. The synthesis output should show readers which sections rest on thin evidence because a source failed. What should you add?

  • A. Nothing; keep it clean
  • B. Remove the affected sections
  • C. Coverage annotations marking well-supported findings versus gaps from unavailable sources
  • D. A generic disclaimer
Show answer

Answer: C. Be transparent about uncertainty where it applies. A hides it. D isn't specific. B loses useful partial information.

πŸ“ Assignment

Do these tasks in order. Each one has a Done when check, so you know when it is complete. The stretch task is optional but close to what the exam expects from an architect. Keep your answers in one notes file or Git repository, and revisit them in your final week of revision together with the cheat sheet in the last lesson of this course.

  1. Task 1: For each scenario, write one sentence describing a system you have built or seen that is similar.
    βœ… Done when: Each of the six scenarios has one sentence describing a real or familiar system, so you can picture it on exam day.
  2. Task 2: Map each scenario to its two most-tested domains without looking back at the lesson.
    βœ… Done when: Your mapping matches the lesson for at least five of the six scenarios when you compare it afterwards.
  3. Stretch: draft one exam-style question of your own for Scenario 6 with four options and an explanation.
    βœ… Done when: Your question has one clearly correct answer, three plausible distractors, and an explanation of why each distractor is wrong.

❓ Frequently Asked Questions

πŸ€” How many scenarios appear on the CCAR-F exam?

Four, picked at random from a bank of six. Each frames roughly 15 questions.

πŸ€” Which scenario is best for QA engineers?

Scenario 5, Claude Code for Continuous Integration, and Scenario 6, Structured Data Extraction, are closest to test-automation work.

πŸ€” Do I need to memorise the tool names in the scenarios?

No, but knowing the setup (for example get_customer before process_refund) saves reading time and helps you spot what a question tests.

πŸ€” Do the mock tests use the same scenarios?

Yes. The five mock tests on this site rotate through all six scenarios so you meet each one at least twice.

🏁 Summary

  • Scenarios 1, 3 and 6 lean on Domains 1, 4 and 5; Scenarios 2, 4 and 5 lean on Domains 2 and 3.
  • Read the scenario once, carefully β€” every question in that block assumes you remember it.
  • Our five mock tests rotate through all six scenarios so you meet each at least twice.
πŸ“ Test yourself: Mock Test 1 (30 scenario-based questions in 60 minutes, with explanations).

Next, continue with Claude Agentic Loop: stop_reason, Tool Results and Anti-Patterns.

🎬 Prefer video? Watch QA, automation and AI testing tutorials on the SQA Tools YouTube channel.

Independent study material by SQA Tools. Not affiliated with, endorsed by or sponsored by Anthropic. Claude is a trademark of Anthropic. Mock questions are original practice items, not real exam content. Exam facts checked against Anthropic's official exam guides and certification FAQ on 11 November 2026.

Claude Certified Architect – Foundations (CCAR-F) Exam Guide

πŸ“š Exam guide v1.0 (July 2026)πŸ”„ Checked against official sources: 11 Nov 2026✏️ Updated: 12 Nov 2026⏱️ 9 min read🎯 Exam overview

πŸ‘‹ In plain words: Before studying anything, it helps to know how the exam is built: how many questions, how they are scored, and which topics never appear. This lesson turns the official exam guide into a short, practical plan. It saves you from studying things that are not tested.

The Claude Certified Architect – Foundations exam tests whether you can make sound trade-off decisions when building real systems with Claude Code, the Claude Agent SDK, the Claude API and the Model Context Protocol (MCP). This lesson breaks down exactly how the exam is built so you study the right things.

πŸ“– What You’ll Learn: You will understand exactly how the CCAR-F exam is built, how it is scored, how to register, and which topics you can safely skip.

πŸ”‘ Key terms

  • Domain: One of the five topic areas of the exam. Each has a weight, meaning its share of the questions.
  • Scenario: A realistic business situation (such as a support bot) that frames a group of questions.
  • Multiple-response item: A question where you must pick more than one answer. The question tells you how many.
  • Agent SDK: Anthropic's toolkit for building AI agents in code.
  • MCP (Model Context Protocol): A standard way to connect Claude to tools and data, like a universal plug.

πŸ“– The story in this lesson

Ravi, ShopNest's QA engineer, has six weeks before his CCAR-F exam. In this lesson he turns the exam guide into a study budget, so he spends most of his time where most of the marks are.

πŸ’‘ Think of it like this

The domain weights work like a restaurant bill split by what each person ordered. Domain 1 ordered the most (27%), so it pays the biggest share of your study hours.

πŸ“‹ Exam format

Exam codeCCAR-F
Items60 β€” multiple-choice and multiple-response (each item says how many to pick)
Structure4 scenarios drawn at random from a bank of 6
Time120 minutes (β‰ˆ 2 minutes per item)
Passing scoreScaled 720 on 100–1,000
Fee$125 (partner tiers Select/Preferred/Global Premier get discounts)
Validity12 months

🌍 Real-world example: Pacing a 120-minute exam

Ravi works out his pace: 60 items in 120 minutes is about 2 minutes per item. He decides to flag any question that takes him over 3 minutes and come back to it, so one hard item can't eat the time for five easy ones.

πŸ“Š The five domains and their weights

#DomainWeightβ‰ˆ items
1Agentic Architecture & Orchestration27%16
2Tool Design & MCP Integration18%11
3Claude Code Configuration & Workflows20%12
4Prompt Engineering & Structured Output20%12
5Context Management & Reliability15%9

Modules 2–6 of this course map one-to-one onto these domains.

🌍 Real-world example: Turning weights into study hours

Ravi has 40 study hours. At 27%, Domain 1 gets about 11 hours, Domains 3 and 4 get 8 hours each, Domain 2 gets 7, and Domain 5 gets 6. His spreadsheet now mirrors the exam itself.

❔ How questions are written

Every question sits inside a realistic production scenario and asks you to choose the best action β€” the root-cause fix, the most effective first step, or the design that guarantees a requirement. Three habits will carry you through most items:

  1. Find the root cause first. Distractors usually fix a different problem.
  2. Prefer the proportionate fix. “First step” questions want the cheap, high-leverage change (better tool descriptions, explicit criteria) before new infrastructure (classifiers, routing layers).
  3. Code beats prompts when it must not fail. Money, identity and compliance need hooks and gates, not “please remember to…”.

🌍 Real-world example: Spotting the proportionate fix

A practice question says ShopNest's bot keeps calling the wrong tool. The options are: build a routing classifier, add 10 examples, or rewrite the tool descriptions. Ravi asks himself what the cheapest fix is that targets the root cause. That is the descriptions, which is exactly what the exam rewards.

πŸ“ Registration in four steps

  1. Sign in to Anthropic Partner Academy with your partner work email.
  2. Open the Architect – Foundations certification page and pay at checkout.
  3. Follow the emailed Pearson link and create your Pearson account (name must match your ID).
  4. Schedule OnVUE or a test centre. Run Pearson’s system test before an online exam.
⚠️ Watch out: Official sources conflict on cancellation: the exam guide says you can reschedule up to 24 hours before; the FAQ says 48 hours. Use 48 to be safe.

🌍 Real-world example: Registration without surprises

Ravi signs in to Partner Academy with his work email, pays, and follows the Pearson link. He types his name exactly as it appears on his passport, then runs the system test the same evening, not five minutes before the exam.

πŸ”Œ What is out of scope

The official guide lists topics that will not appear. Don’t burn study time on: fine-tuning or training models; API billing, keys, OAuth; hosting MCP servers; model internals, RLHF, Constitutional AI; embeddings and vector-database internals; computer use; vision; streaming/SSE implementation; rate limits and pricing maths; cloud-provider configuration; benchmarks; prompt-caching details beyond knowing it exists; tokenisation.

🌍 Real-world example: Skipping what won't be tested

Ravi was about to spend a weekend on embeddings and vector databases. The out-of-scope list says they are not tested, so he moves that weekend to Domain 1 practice questions instead.

🚫 Common beginner mistake: Spreading study time evenly across all five domains. Weight your hours by the domain percentages.

πŸ› οΈ Try it yourself (about 10 minutes)

  1. Write down how many hours you can study in total.
  2. Multiply that by each domain weight (27%, 18%, 20%, 20%, 15%).
  3. Put the hours for each domain into your calendar.
  4. Cross out one topic from the out-of-scope list that you were planning to study.

βœ… You are done when: you have a study-hours budget for all five domains, adding up to your total.

πŸ§ͺ Exam-Style Practice Questions

Try these before opening the answers. They use the same scenario style as the real exam.

Question 1. In a hub-and-spoke research system, why does all subagent communication go through the coordinator?

  • A. The SDK forbids subagents from having tools
  • B. It cuts token use to zero
  • C. It gives observability, consistent error handling and controlled information flow
  • D. Subagents can't run concurrently otherwise
Show answer

Answer: C. Central routing lets you see, handle and control everything. D: parallelism comes from multiple Task calls. B: it doesn't remove token cost. A: false.

Question 2. The system prompt says "Whenever a user mentions 'account', call get_customer." Users asking about "account of the incident" trigger wrong calls. What's the problem?

  • A. The tool schema is invalid
  • B. Temperature is too high
  • C. The model is too small
  • D. Keyword-sensitive system-prompt instructions are overriding well-written tool descriptions
Show answer

Answer: D. Review prompts for keyword triggers that create unintended associations. A, B and C don't explain keyword-driven misfires.

Question 3. Severity labels are inconsistent across runs. What helps most?

  • A. Define each severity level with concrete code examples
  • B. Increase the temperature
  • C. Use only two levels
  • D. Ask Claude to be consistent
Show answer

Answer: A. Concrete anchors give consistent classification. D is vague. C loses information without fixing the ambiguity. B makes it worse.

πŸ“ Assignment

Do these tasks in order. Each one has a Done when check, so you know when it is complete. The stretch task is optional but close to what the exam expects from an architect. Keep your answers in one notes file or Git repository, and revisit them in your final week of revision together with the cheat sheet in the last lesson of this course.

  1. Task 1: Download the official CCAR-F exam guide from Anthropic Partner Academy and read sections 4–6.
    βœ… Done when: You can list all five domains with their weights from memory and say which one carries the most items.
  2. Task 2: Rate yourself 1–5 on each of the five domains and note your two weakest.
    βœ… Done when: Your ratings table has all five domains scored, and your two weakest domains are linked to the matching modules of this course.
  3. Stretch: work out how many minutes you can spend per scenario if you keep 10 minutes for review.
    βœ… Done when: Your time plan adds up to 120 minutes and leaves 10 minutes for flagged questions.

❓ Frequently Asked Questions

πŸ€” How many questions are on the Claude Architect Foundations exam?

Sixty multiple-choice and multiple-response items, presented as four scenarios drawn from a bank of six, in 120 minutes.

πŸ€” Which domain carries the most weight?

Agentic Architecture & Orchestration at 27%, followed by Claude Code Configuration and Prompt Engineering at 20% each.

πŸ€” Is computer use or vision tested on CCAR-F?

No. The official guide lists computer use, vision, streaming implementation, fine-tuning and pricing maths as out of scope.

πŸ€” Can I reschedule the exam?

Yes, through Pearson. The exam guide says up to 24 hours before, while the FAQ says 48 hours, so reschedule at least 48 hours ahead to be safe.

🏁 Summary

  • 60 items, 4 scenarios, 120 minutes, scaled 720 to pass.
  • Domain 1 (agentic architecture) is the heaviest at 27% β€” master it.
  • Most wrong answers fix a different problem, over-engineer a first step, or trust prompts where code is required.
πŸ“ Test yourself: Mock Test 1 (30 scenario-based questions in 60 minutes, with explanations).

Next, continue with The 6 CCAR-F Exam Scenarios Explained.

🎬 Prefer video? Watch QA, automation and AI testing tutorials on the SQA Tools YouTube channel.

Independent study material by SQA Tools. Not affiliated with, endorsed by or sponsored by Anthropic. Claude is a trademark of Anthropic. Mock questions are original practice items, not real exam content. Exam facts checked against Anthropic's official exam guides and certification FAQ on 11 November 2026.

Claude Certifications Explained: All 4 Anthropic Exams (2026)

πŸ“š Exam guide v1.0 (July 2026)πŸ”„ Checked against official sources: 11 Nov 2026✏️ Updated: 12 Nov 2026⏱️ 10 min read🎯 Exam overview

πŸ‘‹ In plain words: Anthropic offers four Claude certifications, and picking the wrong one wastes weeks of study. This lesson is a map: what each exam covers, who is allowed to take it, and which one fits a tester or developer. You don't need any AI experience to follow it.

Anthropic now runs four role-based Claude certifications. Before you spend weeks studying, you need to know which exam fits your role, who is allowed to sit it, and what the exam actually looks like. This lesson gives you that map, checked against Anthropic’s official exam guides and FAQ.

πŸ“– What You’ll Learn: You will be able to compare the four Claude certifications, check whether you are eligible, and pick the right first exam for your role.

πŸ”‘ Key terms

  • Claude: Anthropic's AI model. You talk to it in an app, or call it from code through the Claude API.
  • Certification: A proctored exam (watched by an invigilator) that proves a skill. It is different from a free course certificate.
  • Claude Partner Network: Companies that officially work with Anthropic to deliver Claude to clients. Only their employees can sit the exams today.
  • Scaled score: Your result converted to a 100–1,000 scale. 720 passes.
  • Pearson VUE: The testing company that runs the exams, online or at a test centre.

πŸ“– The story in this lesson

Throughout this course we follow ShopNest, an online shop. Asha runs ShopNest's customer-support bot, built on Claude. Ravi is a QA engineer who looks after ShopNest's test-automation pipeline. Both want a Claude certification. This lesson helps them pick the right one.

πŸ’‘ Think of it like this

The four certifications are like driving licences for different vehicles. Associate is the car licence for everyday users. Developer is the licence for building the car. Architect – Foundations is for designing whole delivery fleets. Architect – Professional is for running the national transport network.

πŸ‘€ The four Claude certifications at a glance

CertificationCodeWho it’s forItemsTimeFee*
Claude Certified Associate – FoundationsCCAO-FBusiness users of Claude (Projects, Artifacts, connectors)60120 min$99
Claude Certified Developer – FoundationsCCDV-FEngineers building with the API, Agent SDK, Claude Code and MCP53120 min$125
Claude Certified Architect – FoundationsCCAR-FSolution architects designing production agentic systems60120 min$125
Claude Certified Architect – ProfessionalCCAR-PSenior architects: enterprise integration, governance, evaluation63120 min$175

*Fee before partner discount. All four: multiple-choice and multiple-response items, scaled passing score of 720 on a 100–1,000 scale, valid for 12 months. Source: Anthropic’s official exam guides (v1.0, July 2026) and the Partner Academy certification FAQ, checked 11 November 2026.

🌍 Real-world example: Asha and Ravi compare exams

Asha uses Claude daily but writes no code, so Associate (CCAO-F) looks right. Ravi writes test scripts and wants Claude to review pull requests in CI. That is architect-level design, so the table points him to Architect – Foundations (CCAR-F): 60 items, 120 minutes, $125.

πŸͺͺ Who can take the exams?

This catches most people out: the proctored exams are only open to people who work at organisations in the Claude Partner Network. You register on Anthropic Partner Academy using a company email address on your partner’s recognised domain β€” personal email addresses are rejected. Organisations that deliver Claude to clients can apply to the network at claude.com/partners (membership is free).

πŸ’‘ Tip: Not at a partner yet? You can still learn everything on this course and take Anthropic’s free public Academy courses at anthropic.skilljar.com. Those end with a certificate of completion β€” useful, but not the same as the proctored certification.

🌍 Real-world example: Checking eligibility before studying

Ravi tries to register with his personal Gmail address and is rejected. His manager confirms that ShopNest's IT partner is in the Claude Partner Network, so Ravi registers with his partner work email instead. Lesson: check eligibility on day one, not after six weeks of study.

πŸ–₯️ How the exams are delivered and scored

  • Proctored by Pearson VUE β€” online (OnVUE) or at a test centre. Closed book: no notes, documentation, AI assistants or translation tools.
  • ID check: 18+, government photo ID, name must exactly match your registration.
  • Scoring: criterion-referenced scaled score; 720 passes. Your report shows percent-correct per domain, but pass/fail is based only on the total.
  • Not published: the raw percentage that equals 720. Don’t trust anyone quoting “72% raw”.
  • Retakes: wait 14 days after a first fail, 30 after a second, 90 after a third; max 4 attempts per rolling 12 months; full fee each attempt.
  • Renewal: a free, non-proctored renewal assessment if you renew on time; lapse and you resit the full exam.
  • Languages: English and Japanese.

🌍 Real-world example: Planning exam day

Ravi books an online (OnVUE) exam. The day before, he runs Pearson's system test, clears his desk and checks that the name on his passport matches his registration exactly. He also stops worrying about a magic raw percentage: only the scaled 720 counts.

πŸ“Ž Important: exam updates on 7 December 2026

⚠️ Watch out:

Pearson VUE’s Claude certification page announces: “Certification exams update on December 7, 2026.” The Associate, Developer and Architect – Professional exams get updated content from that date, with updated exam guides due on 17 November 2026.

Architect – Foundations (CCAR-F) is not part of that update β€” which is why this course starts with it. Course material for the other three will follow the new guides.

🌍 Real-world example: Choosing the right exam guide

Asha plans to take Associate in January 2027, after the 7 December update. So she studies the new exam guide due on 17 November 2026, not the July version. Ravi's exam, CCAR-F, is not part of the update, so his guide stays the same.

🧭 Which certification should you take first?

  • You use claude.ai daily but don’t code β†’ Associate – Foundations.
  • You write Python/TypeScript against the Claude API β†’ Developer – Foundations.
  • You design agent systems, configure Claude Code for a team, or own CI and MCP integrations β†’ Architect – Foundations. If you are a QA or automation engineer, start here: its CI/CD, code-review and structured-extraction scenarios are your day job.
  • You lead enterprise rollouts (RAG, governance, compliance) β†’ Architect – Professional, ideally after Foundations.

🌍 Real-world example: A QA engineer's first pick

Ravi's daily work is CI pipelines, code review and checking data extracted from documents. Those match three of the six CCAR-F scenarios almost exactly, so Architect – Foundations is the natural first exam for him.

🚫 Common beginner mistake: Studying for weeks before checking eligibility. The proctored exams are open only to Claude Partner Network employees using a company email address.

πŸ› οΈ Try it yourself (about 10 minutes)

  1. Write your job role in one line.
  2. Pick the certification that matches it from the table above.
  3. Ask your manager, or check claude.com/partners, whether your company is in the Claude Partner Network.
  4. Write down which exam guide applies to your planned exam date: July 2026 or 17 November 2026.

βœ… You are done when: you have one exam code, a yes or no for eligibility, and the right exam-guide version noted.

πŸ§ͺ Exam-Style Practice Questions

Try these before opening the answers. They use the same scenario style as the real exam.

Question 1. Who can currently register for the proctored CCAR-F exam?

  • A. Anyone with a personal email address
  • B. Employees of Claude Partner Network organisations, using a company email on the partner's domain
  • C. Only Anthropic employees
  • D. Anyone who has finished a free Anthropic Academy course
Show answer

Answer: B. Eligibility is limited to Partner Network employees. A: personal email addresses are rejected. C: too narrow. D: Academy certificates of completion don't grant eligibility.

Question 2. What does a pass on any of the four Claude certification exams require?

  • A. 72% of items answered correctly
  • B. At least 70% in every domain
  • C. A scaled score of 720 on a 100–1,000 scale
  • D. Passing each scenario separately
Show answer

Answer: C. Pass or fail depends only on the total scaled score. A: the raw percentage that equals 720 is not published. B and D: per-domain results are reported but don't decide the outcome.

Question 3. You failed your first attempt. What is the earliest you can retake the exam?

  • A. Immediately
  • B. After 14 days
  • C. After 30 days
  • D. After 90 days
Show answer

Answer: B. The waits are 14 days after a first fail, 30 after a second and 90 after a third, with at most four attempts per rolling 12 months.

πŸ“ Assignment

Do these tasks in order. Each one has a Done when check, so you know when it is complete. The stretch task is optional but close to what the exam expects from an architect. Keep your answers in one notes file or Git repository, and revisit them in your final week of revision together with the cheat sheet in the last lesson of this course.

  1. Task 1: Write down which of the four certifications fits your current role and why, in two sentences.
    βœ… Done when: You can name the exam code, item count and fee of your chosen certification without looking, and explain in one line why it fits your role better than the other three.
  2. Task 2: Check whether your employer is in the Claude Partner Network (ask your Anthropic partnership manager or search claude.com/partners). Note the result.
    βœ… Done when: You have a written yes or no for Partner Network membership, plus the name of the person or page that confirmed it.
  3. Stretch: list the three exams that change on 7 December 2026 and decide whether your exam date falls before or after it.
    βœ… Done when: Your note states your planned exam date and whether the July 2026 or the 17 November 2026 exam guide applies to it.

❓ Frequently Asked Questions

πŸ€” Can I take a Claude certification exam as an individual?

Not currently. Proctored exams are open only to employees of Claude Partner Network organisations, registering with a company email on the partner's domain.

πŸ€” What is the passing score for Claude certifications?

All four exams use a scaled score from 100 to 1,000, and 720 passes. Anthropic does not publish the raw percentage that equals 720.

πŸ€” How long is a Claude certification valid?

Twelve months. On-time renewal is a free, non-proctored assessment on Anthropic Partner Academy; a lapsed credential needs the full exam again.

πŸ€” Are Anthropic Academy course certificates the same as certifications?

No. The free public Academy courses give a certificate of completion. Certifications are proctored exams delivered by Pearson VUE.

🏁 Summary

  • Four exams, all 120 minutes, all pass at a scaled 720/1000, all valid 12 months.
  • Only Claude Partner Network employees can sit the proctored exams.
  • Three exams change on 7 Dec 2026; Architect – Foundations does not.
  • Architect – Foundations is the best first exam for technical and QA professionals.
πŸ“ Test yourself: Mock Test 1 (30 scenario-based questions in 60 minutes, with explanations).

Next, continue with Claude Certified Architect – Foundations (CCAR-F) Exam Guide.

🎬 Prefer video? Watch QA, automation and AI testing tutorials on the SQA Tools YouTube channel.

Independent study material by SQA Tools. Not affiliated with, endorsed by or sponsored by Anthropic. Claude is a trademark of Anthropic. Mock questions are original practice items, not real exam content. Exam facts checked against Anthropic's official exam guides and certification FAQ on 11 November 2026.