The study guide
What CCAR-F is, and what this guide covers
This ccar-f study guide covers the Claude Certified Architect - Foundations exam: what Anthropic tests, who the exam is written for, and how to prepare without paying for anything beyond the exam itself. CCAR-F is the architect-level Foundations credential in the Claude Certification Program. It is a 60-item, 120-minute proctored exam delivered by Pearson VUE, online or at a test centre, with a pass mark of 720 on a scaled 100 to 1,000 range, a fee of $125, and a credential that stays valid for 12 months from the award date.
The exam is scenario-framed. Four scenarios are presented from a published bank of six, and each sets a production context (a support agent, a research pipeline, a CI reviewer, an extraction system) that frames a run of items. Items are multiple-choice and multiple-response, and every multiple-response stem states how many options to select.
The Exam Guide v1.0, effective July 2026, is the only authority this page follows. It names five domains, weighted 27, 18, 20, 20 and 15 percent, and 30 task statements. Everything below is derived from that guide and from Anthropic's documentation; none of it is an excerpt, and none of it claims to be exam content.
Study guide text checked against Exam Guide v1.0 (July 2026) on 17 September 2026. It is written from the published blueprint and the official documentation, never from a sitting.
The blueprint
Exactly what CCAR-F tests you on
5 domains and 30 published objectives, each with its official weight, what the domain tests, the decision rules that settle most of its items, the traps the wrong options set, and every objective in plain words, with the official documentation page to read where there is one.
1
Agentic Architecture & Orchestration
27% of the exam · 7 published objectives
27%
The heaviest domain, about 16 items on a 60-item paper, tests whether you can build an agent that runs until the model says it is finished and a coordinator that hands out work and gets it back intact. Seven task statements sit here: the agentic loop and its stopping condition, the coordinator-subagent pattern, how subagents are spawned and what context they are given, enforcement and handoff in multi-step workflows, Agent SDK hooks that intercept tool calls or results, task decomposition, and session state across resume and fork.
Items are framed as production symptoms rather than definitions. A log shows the agent skipping identity verification before some refunds; a research report covers only part of its topic and the coordinator's decomposition explains why; a resumed session reasons about files that have since changed. The stem asks which change most effectively fixes the symptom, and the options split into those that alter the structure of the system and those that alter its wording. The structural answer usually wins here, but only when the stem has established that compliance must be deterministic or that the failure is architectural. Read for the sentence that says what cannot be allowed to go wrong.
Decision rules
- Stop the loop on the model's stop reason, never on an iteration cap or on spotting text that sounds like a conclusion.
- A subagent knows only what its prompt carries, so put prior findings and their sources into the prompt rather than assuming inheritance.
- When a business rule must always hold, enforce it in code with a hook or a prerequisite gate; a prompt instruction is guidance with a failure rate.
- Route every subagent exchange through the coordinator so that errors, attribution and observability have one owner.
- Resume a session when its earlier context is still valid; start fresh with a written summary when the old tool results are stale.
Traps
- The option that strengthens the system prompt to cure a compliance failure the stem has tied to financial consequences.
- Blaming a downstream subagent for a coverage gap that the coordinator's own task split created.
- Spawning workers one turn at a time when several Task calls in a single response would have run them in parallel.
- A fixed cap on iterations presented as the loop's primary stopping mechanism.
Objectives
- Design and implement agentic loops for autonomous task execution. Build a request, execute, return loop that continues while the model asks for a tool and ends when it signals a finished turn, feeding each tool result back into the conversation. Read: Tool use with Claude
- Orchestrate multi-agent systems with coordinator-subagent patterns. Run a hub-and-spoke system in which one coordinator decomposes the task, decides which specialists to call for a given query, and aggregates what they return. Read: Subagents
- Configure subagent invocation, context passing, and spawning. Spawn subagents through the Task tool with the right tool allowances, hand each one its context explicitly in structured form, and launch independent workers in parallel. Read: Subagents
- Implement multi-step workflows with enforcement and handoff patterns. Separate rules a prompt may suggest from rules code must enforce, gate downstream tool calls on completed prerequisites, and hand off to humans with a structured summary. Read: Hooks reference
- Apply Agent SDK hooks for tool call interception and data normalization. Use hook events to normalise mixed data formats in tool results before the model reads them, and to block or redirect calls that would break a policy threshold. Read: Hooks reference
- Design task decomposition strategies for complex workflows. Choose between a fixed chain of steps and an adaptive plan that grows from what each step discovers, and split large reviews into per-file and cross-file passes. Read: Chain complex prompts for stronger performance
- Manage session state, resumption, and forking. Resume named sessions, fork them to compare approaches from a shared baseline, tell a resumed session what changed, and know when a fresh session with an injected summary is safer. Read: Common workflows
2
Tool Design & MCP Integration
18% of the exam · 5 published objectives
18%
About 11 items test whether the contract between the model and the outside world lets the model choose correctly and recover when something fails. Five task statements cover it: tool descriptions as the main lever for tool selection; error responses that carry a category and a retryable flag; how tools are distributed across agents and how tool_choice is configured; MCP server scoping, credentials and resources in Claude Code and agent workflows; and the built-in file and shell tools, with the job each one is for.
The framing is diagnostic. A log shows one tool being called where its near-twin was meant, and both descriptions are a single vague line. A synthesis agent is running web searches it should not have. An agent with eighteen tools picks the wrong one. An Edit fails because the anchor text appears twice. A team wants a Jira integration and someone proposes writing a server from scratch. In each case the options include a heavier intervention (a routing layer, a classifier, consolidation, a custom server) and a lighter one that addresses the actual cause. The domain rewards the proportionate first step, and expects you to know which file a shared server belongs in and how a secret stays out of version control.
Decision rules
- When two tools are confused, fix the descriptions first: inputs, example queries, edge cases, and the boundary against the sibling tool.
- An error response says what kind of failure occurred and whether retrying can help; a generic failure message leaves the agent guessing.
- Give each agent the few tools its role needs, and add a scoped cross-role tool only for a measured, high-frequency need.
- Shared team servers go in the project .mcp.json with environment variable expansion for tokens; personal experiments go in the user-level file.
- Grep searches content, Glob matches paths, Edit changes one unique anchor, and Read followed by Write is the fallback when the anchor is not unique.
Traps
- Adding few-shot examples or a keyword routing layer before the tool descriptions themselves have been fixed.
- Treating a valid empty result as a failure, or letting a timeout come back looking like an empty result.
- Handing an agent every available tool so that it can cope with anything.
- Building a custom MCP server for a standard integration that a community server already covers.
Objectives
- Design effective tool interfaces with clear descriptions and boundaries. Write tool descriptions that state purpose, inputs, outputs and the boundary against similar tools, and rename or split tools whose descriptions overlap. Read: How to implement tool use
- Implement structured error responses for MCP tools. Return MCP tool errors with a category, a retryable flag and a readable explanation so the agent can retry, recover locally or explain, instead of guessing. Read: Model Context Protocol (MCP)
- Distribute tools appropriately across agents and configure tool choice. Limit an agent's tools to those its role needs, replace generic tools with constrained ones, and use tool_choice to force, require or leave open a tool call. Read: How to implement tool use
- Integrate MCP servers into Claude Code and agent workflows. Configure MCP servers at project or user scope, keep credentials in expanded environment variables, describe MCP tools well enough to be chosen, and expose catalogs as resources. Read: Connect Claude Code to tools via MCP
- Select and apply built-in tools (Read, Write, Edit, Bash, Grep, Glob) effectively. Pick Grep, Glob, Read, Write, Edit and Bash by the job each does, and build understanding of a codebase incrementally rather than reading every file first. Read: Claude Code settings
3
Claude Code Configuration & Workflows
20% of the exam · 6 published objectives
20%
About 12 items test how a team configures Claude Code and how an individual works with it well. Six task statements: the CLAUDE.md hierarchy across user, project and directory levels with imports and topic rule files; custom slash commands and skills with their frontmatter options; path-scoped rules that load only for matching files; plan mode against direct execution; iterative refinement through examples, tests and questions; and running Claude Code non-interactively in a CI pipeline with structured output.
The scenarios are team situations. A new engineer misses the conventions because they live in someone's home directory. A review command must ship with the repository. Test files sit beside the code they test in every directory and must all follow one convention. A monolith is being split into services. A pipeline job hangs waiting for input. The distractors are often plausible-sounding mechanisms that do not exist, or real mechanisms applied at the wrong scope, so knowing the actual file locations and flags matters more here than anywhere else. The other recurring test is judgment about scale: when exploration and design should precede any file change, and when a well-understood fix should simply be made.
Decision rules
- If a rule must reach every teammate, it lives in version control: the project CLAUDE.md, .claude/rules/ or .claude/commands/, never a home-directory file.
- Conventions that follow a file type across directories belong in a path-scoped rule with a glob, not in a CLAUDE.md per directory.
- Use plan mode for architectural or many-file changes with more than one valid approach; use direct execution for a scoped fix with a clear cause.
- When prose instructions produce inconsistent results, give two or three concrete input and output examples or a failing test instead of more prose.
- In CI, run non-interactively with the -p flag and ask for JSON against a schema, and carry earlier findings forward so a re-run reports only what is new.
Traps
- A configuration mechanism that does not exist, such as a commands array in a config file, a headless environment variable or a --batch flag.
- Putting every convention into one root CLAUDE.md and relying on the model to infer which section applies to the file in hand.
- Starting in direct execution with a promise to switch to plan mode if the work turns out to be complicated.
- Having the session that generated the code review its own changes.
Objectives
- Configure CLAUDE.md files with appropriate hierarchy, scoping, and modular organization. Place instructions at the right level of the CLAUDE.md hierarchy, keep them modular with imports and topic rule files, and diagnose which memory files a session actually loaded. Read: Manage Claude's memory
- Create and configure custom slash commands and skills. Create project-scoped or personal slash commands and skills, using frontmatter to fork context, restrict tools during execution and prompt for missing arguments. Read: Agent Skills
- Apply path-specific rules for conditional convention loading. Write rule files whose frontmatter globs load them only when a matching file is edited, so a convention follows the file type across the whole tree. Read: Manage Claude's memory
- Determine when to use plan mode vs direct execution. Judge when a task's scale, ambiguity or architectural weight calls for plan mode and an Explore pass, and when a scoped fix should simply be executed. Read: Common workflows
- Apply iterative refinement techniques for progressive improvement. Improve results progressively with concrete examples, tests written before the code, an interview step in unfamiliar domains, and the right grouping of interacting fixes. Read: Common workflows
- Integrate Claude Code into CI/CD pipelines. Run Claude Code non-interactively in pipelines with schema-constrained JSON output, project context from CLAUDE.md, prior findings in context, and an independent review instance. Read: Claude Code GitHub Actions
4
Prompt Engineering & Structured Output
20% of the exam · 6 published objectives
20%
About 12 items test whether you can shape what is asked for and what comes back, and prove that a change helped. Six task statements: explicit criteria in place of adjectives, and their effect on false positives; few-shot examples for consistency and for ambiguous cases; structured output through tool use and JSON schemas, including the tool_choice modes and schema design; loops that validate an extraction, retry it and feed the error back; batch processing strategy; and review architectures that use more than one instance or more than one pass.
The scenarios come from the CI reviewer and the extraction pipeline. A reviewer flags so many non-issues that developers stop reading it. An extraction returns empty required fields, or invents a value to satisfy one. A manager proposes the Message Batches API for a pre-merge check because it costs half as much. A review of fourteen files praises a pattern in one file and condemns it in another. Two ideas do most of the work: a schema removes syntax errors but not semantic ones, so meaning still has to be validated; and latency tolerance, not cost, decides whether work can be batched. Expect at least one item where the tempting answer is a bigger model or a longer context window and the right one is structural.
Decision rules
- Replace adjectives with categories: name what to report and what to skip, with a concrete example for each severity level.
- Two to four few-shot examples that show the reasoning for a borderline case do more than a longer instruction.
- Schema-enforced tool use removes syntax errors but not semantic ones, so validate meaning separately and feed the specific error back on retry.
- Make a field optional when the source may not contain it; a required field invites a fabricated value.
- Batch only work that nobody is waiting on: with no latency guarantee and a window of up to 24 hours, a blocking check cannot be batched.
Traps
- An instruction to report only high-confidence findings offered as the fix for precision.
- Retrying an extraction whose missing value is simply absent from the source document.
- A self-review instruction or extended thinking offered in place of an independent second instance.
- A larger context window offered as the cure for attention dilution across many files.
Objectives
- Design prompts with explicit criteria to improve precision and reduce false positives. Write review and classification prompts with explicit, categorical criteria and severity examples so that false positives fall without hiding the real findings. Read: Be clear, direct, and detailed
- Apply few-shot prompting to improve output consistency and quality. Use a small set of targeted examples to fix output format, show how ambiguous cases are handled, and let the model generalise to patterns the examples did not list. Read: Use examples (multishot prompting) to guide Claude's behavior
- Enforce structured output using tool use and JSON schemas. Obtain schema-compliant output through tool use, pick the right tool_choice mode for the situation, and design schemas with optional fields and extensible enums. Read: How to implement tool use
- Implement validation, retry, and feedback loops for extraction quality. Build validation and retry loops that return the specific error with the original input, recognise when a retry cannot help, and record the pattern behind dismissed findings. Read: Increase output consistency
- Design efficient batch processing strategies. Match the Message Batches API to latency-tolerant work, plan submission windows against a service-level target, and resubmit only the failed items by their custom_id. Read: Batch processing
- Design multi-instance and multi-pass review architectures. Design review as independent instances and focused passes, per file for local issues and then across files for data flow, with self-reported confidence where it helps routing. Read: Chain complex prompts for stronger performance
5
Context Management & Reliability
15% of the exam · 6 published objectives
15%
The smallest domain by weight, about 9 items, and the one most likely to settle an item that looks as if it belongs elsewhere. Six task statements: keeping critical facts alive across a long interaction; escalation and ambiguity resolution; error propagation between agents; context in large codebase exploration; human review workflows with confidence calibration; and provenance when several sources feed one synthesis. Each describes a failure that stays silent until someone checks, which is why so many correct answers here are structural rather than instructional.
The framing is the long-running system that has quietly gone wrong. A support conversation is summarised and a refund amount becomes vague. An agent escalates easy damage claims while trying to settle policy exceptions on its own. A report cites a statistic with no source because attribution was lost two steps earlier. An extraction system shows 97 percent accuracy overall and nobody has looked at one document type. A stem here often names a proxy (sentiment, a self-rated confidence, an aggregate accuracy) and asks whether it should drive a decision; the answer replaces the proxy with an explicit criterion or a measured segment. Read for the fact that must survive, and for who would notice if it did not.
Decision rules
- Keep transactional facts, amounts, dates and identifiers in a structured block carried in every prompt, outside whatever gets summarised.
- Escalate when the customer asks for a human, when policy is silent or ambiguous, or when no progress is being made; sentiment and self-rated confidence are not triggers.
- An error travelling up to the coordinator carries the failure type, what was attempted, any partial results and the alternatives.
- Before trusting an aggregate accuracy figure, break it down by document type and field, and sample the high-confidence tail at random.
- When credible sources disagree, keep both values with their attribution and dates; do not pick one.
Traps
- Tighter progressive summarisation offered as the fix for a long conversation that keeps losing its numbers.
- A confidence score the model gives itself used as the gate for escalation.
- An empty result set marked as success when the underlying call actually timed out.
- Cutting human review because overall accuracy is high, without checking each segment first.
Objectives
- Manage conversation context to preserve critical information across long interactions. Keep amounts, dates and identifiers alive across long interactions by extracting them into a persistent block, trimming tool output to relevant fields, and ordering inputs to counter position effects. Read: Long context prompting tips
- Design effective escalation and ambiguity resolution patterns. Set escalation rules on explicit requests, policy gaps and stalled progress, show them with examples, and ask for more identifiers when a lookup returns several matches.
- Implement error propagation strategies across multi-agent systems. Propagate errors between agents with the failure type, the attempted action, partial results and alternatives, after the subagent has tried local recovery for transient faults.
- Manage context effectively in large codebase exploration. Explore a large codebase without exhausting context by delegating verbose discovery to subagents, keeping scratchpad files, summarising between phases and compacting when needed. Read: Manage costs effectively
- Design human review workflows and confidence calibration. Calibrate human review with field-level confidence scores checked against labelled sets, stratified random sampling, and accuracy measured separately per document type and per field. Read: Create strong empirical evaluations
- Preserve information provenance and handle uncertainty in multi-source synthesis. Preserve claim-to-source mappings and collection dates through synthesis, annotate conflicting figures with their sources, and separate settled findings from contested ones. Read: Reduce hallucinations
Weights are the official domain weightings from the exam guide. Objective titles are Anthropic's published wording; the sentence after each is ours.
Practice
Six CCAR-F practice questions, written for the 2026 blueprint
Written for this page from the official guide's domains and objectives, never recalled from a sitting. Each shows its key and the reason every option holds or fails. The CCAR-F mock exam has the full paper under a clock, with no account needed.
Question 1 · Domain 1: Agentic Architecture & Orchestration · Single responseYour agent loop stops after six iterations, or sooner whenever the assistant message contains any text. Traces show runs ending with a requested tool call that never ran, and users get half-finished plans. How should the loop decide when to stop?
- A. Raise the iteration cap to twelve and keep stopping whenever the reply contains text.
- B. Continue while stop_reason is tool_use and stop when it is end_turn.
- C. Tell the model to end each finished plan with DONE and stop when that word appears.
- D. Stop on the first tool_use block and queue it for later.
Answer: B. Branch on stop_reason, not text or caps
The guide's loop control continues while stop_reason is tool_use and terminates on end_turn, with each tool result added to the history between iterations. It names three anti-patterns: checking for assistant text as a completion signal, arbitrary iteration caps as the main stop, and parsing natural language for termination. A response can carry text and a tool_use block together, which is why the current loop ends too early.
A. This keeps two anti-patterns from the guide: a cap as the main stopping mechanism and assistant text as a completion signal. Runs still end with tools unrun.
B. stop_reason is the documented signal. The loop runs each requested tool while it reads tool_use and finishes only when the model reports end_turn.
C. A DONE word is a natural-language signal the model may omit or emit early. The guide names parsing text for termination as an anti-pattern.
D. Stopping on tool_use ends the loop exactly when the model needs a tool result. The plan can never finish inside the loop.
Question 2 · Domain 1: Agentic Architecture & Orchestration · Single responseYour coordinator passes the analysis subagent's findings to the synthesis subagent as one block of prose, with sources mentioned along the way. Every subagent completes without error, yet reviewers find that many claims in the final reports cite the wrong paper. Which change best preserves attribution?
- A. Tell the synthesis subagent to read the coordinator's conversation history to find each claim's source.
- B. Give the synthesis subagent web search tools to look up any citation it is unsure of.
- C. Raise max_tokens for the synthesis subagent and ask it for a citation after every claim.
- D. Pass each finding with its source URL, document and page as separate fields.
Answer: D. Pass content and source metadata as separate fields
The guide's context-passing skills include structured data formats that separate content from metadata, such as source URLs, document names and page numbers, so attribution survives the handoff between agents. Prose that mixes claims and sources invites the synthesis subagent to pair them wrongly. A subagent never sees the coordinator's earlier turns, giving synthesis search tools reaches outside its role, and a larger output budget does not restore lost mappings.
A. A subagent never sees the coordinator's earlier turns. Whatever synthesis needs must be in its own prompt, and this points at material it cannot see.
B. The guide warns that agents with tools outside their specialization tend to misuse them, and searching again does not fix the mapping lost in prose.
C. The citations are wrong, not missing for lack of space. More output room repeats the same pairing errors at greater length.
D. Separate fields for the claim and its source, document and page keep each mapping intact, and synthesis can cite the right paper.
Question 3 · Domain 2: Tool Design & MCP Integration · Single responseYour process_refund MCP tool returns isError with the text "Operation failed" when a refund breaks the 30-day returns policy, and the agent retries three times before telling the customer something went wrong. Policy breaches are never retryable, but timeouts on the same tool are. Which change best fixes the wasted retries?
- A. Keep the error text and add a system prompt rule that refund errors are never retried.
- B. Move the retries inside the tool and return one final error after three attempts.
- C. Return an errorCategory of business, isRetryable false and a customer-friendly explanation.
- D. Return a success response that says the refund is not applicable.
Answer: C. Business errors are not retryable
The guide's MCP error pattern returns structured metadata: a category for the error, a flag saying whether a retry can help and a plain description, and for business rule violations it calls for a retryable flag of false with a customer-friendly explanation the agent can pass on. A generic "Operation failed" hides the difference between a policy breach and a timeout. A blanket prompt rule would also stop retries for real timeouts, and a success response hides the failure.
A. A blanket rule also blocks retries on genuine timeouts, which the stem says should be retried, and the error still gives no reason to share with the customer.
B. Internal retries still repeat a call that can never succeed, and the agent still gets a generic error with nothing useful to tell the customer.
C. Category and retry flag tell the agent not to try again, and the explanation lets it tell the customer why the refund cannot go through.
D. Marking a failure as success hides it. The agent may tell the customer the request was handled when no refund was issued.
Question 4 · Domain 3: Claude Code Configuration & Workflows · Single responseYour tech lead's Claude Code sessions follow the team's testing and naming standards, but three new engineers' sessions ignore them. The standards, which apply to every file in the project, are in ~/.claude/CLAUDE.md on the lead's machine and nowhere in the repository. Where should the standards live?
- A. In a project-level CLAUDE.md at the repository root, committed to version control.
- B. In each new engineer's ~/.claude/CLAUDE.md, copied from the lead's file during onboarding.
- C. In a project skill that each engineer runs before a coding task.
- D. In the lead's file, checked with /memory at each session start.
Answer: A. Shared standards belong in project-level CLAUDE.md
The guide's CLAUDE.md hierarchy has user, project and directory levels, and anything in ~/.claude/CLAUDE.md belongs to one user's machine and is never committed with the code. Diagnosing a new team member who lacks instructions kept at user level is one of its listed skills. Standards for every file belong in a project-level CLAUDE.md that each clone receives. Copies drift, skills load only on demand, and /memory only shows what is loaded.
A. Project-level CLAUDE.md is committed with the code, and every engineer who clones or pulls the repository loads the same standards in every session.
B. Personal copies work until the lead changes a standard. Each machine then drifts, and every later hire begins with none of them.
C. Skills load when someone invokes them. Standards for every file need to be in CLAUDE.md, which loads in every session.
D. /memory shows which memory files are loaded, which helps diagnosis. It cannot load the lead's user-level file on another engineer's machine.
Question 5 · Domain 4: Prompt Engineering & Structured Output · Single responseYou extract fields from scanned mail with three extraction tools, one each for invoices, claim forms and policy letters, and the type is unknown until the model reads the scan. With tool_choice set to auto, some documents come back as prose, and the parser rejects them. Which change fixes this?
- A. Set tool_choice to any, letting the model pick which of the three tools to call.
- B. Force the claim form tool on every request and handle other document types in a second pass.
- C. Keep auto and write a prompt rule that demands a tool call in every single reply.
- D. Merge the three schemas into one tool with every field optional.
Answer: A. Use tool_choice any for unknown document types
The guide distinguishes auto, where the model may return text instead of calling a tool, any, where it must call a tool but can choose which, and forced selection of one named tool. With several schemas and an unknown document type, any guarantees structured output while the model still picks the schema that fits. Forcing one tool misfiles the other types, a prompt rule stays probabilistic, and one all-optional schema weakens what the parser relies on.
A. With any, every response is a call to one of the three tools, and the model still picks the schema that matches the document it read.
B. Forcing one named tool makes every invoice and policy letter fit the claim form schema, and the second pass adds work to undo the mistake.
C. With auto the model may still answer in text. A prompt rule lowers that rate but does not guarantee a tool call.
D. A single all-optional schema stops each type from enforcing its own fields, and the parser depends on the three existing schemas.
Question 6 · Domain 5: Context Management & Reliability · Single responseYour billing agent's policy covers installment plans and late fees but says nothing about hardship waivers. When patients ask for a waiver, the agent grants or refuses one on its own, and two refusals became complaints. What should you change, given that billing staff have limited capacity?
- A. Send every conversation that mentions any payment difficulty to billing staff.
- B. Tell the agent to decide waivers by applying the closest rule in the late-fee policy.
- C. Escalate requests the policy does not cover, using explicit criteria.
- D. Escalate any conversation in which the patient's messages read as frustrated or upset.
Answer: C. Escalate when the policy is silent
The guide lists policy gaps and exceptions, not just complex cases, as escalation triggers, including requests on which policy is ambiguous or silent. Its skill for calibration is explicit escalation criteria with few-shot examples in the system prompt. Routing every payment conversation overwhelms limited staff, deciding by analogy is the improvisation causing complaints, and sentiment is an unreliable proxy for whether a case needs a human.
A. This escalates many requests the agent can resolve under its policy, which overwhelms limited staff without targeting the waiver gap.
B. Deciding by analogy is still the agent making a call the policy never gave it, the behavior that produced the complaints.
C. Explicit criteria in the system prompt, ideally with few-shot examples, teach the agent to escalate exactly the requests the policy does not cover, such as hardship waivers.
D. The guide calls sentiment an unreliable proxy for case complexity. A calm waiver request would still be decided by the agent.
Sit the CCAR-F mock, no account
