CCA-F start here · Domain 1 · Support agent mind maps

Customer support agent mind maps

Everything the CCA-F exam asks about the customer support agent, on one page. It starts with which exam scenarios bring these questions. Then six mind maps, each in the form "what you see, where the fault is, the fix", with the rule to remember, the exam-guide line it comes from, and one practice question.

Domain 1 · 27%Domain 5 · 15%Guide 1.1, 1.4, 1.5, 5.1, 5.2About 30 minutes

Which scenarios ask about the support agent?

The exam shows you 4 scenarios out of a bank of 6. One is the support agent itself. The same ideas come up elsewhere:

#ScenarioDomainsSupport-agent questions?Maps to study
1Customer Support Resolution AgentD1, D2, D5Yes, the core one. Agent SDK, MCP tools get_customer, lookup_order, process_refund, escalate_to_human, target of 80%+ resolved on first contactAll six, plus MCP maps 3 and 4
3Multi-Agent Research SystemD1, D2, D5Partly. The same agent loop and hooks run inside every subagent1, 2
2, 4, 5, 6Claude Code and extraction scenarios—Hooks vs instructions shows up in Claude Code too2
What this means for you. If the four are picked at random, scenario 1 is on your paper about 2 times in 3. Three of the twelve official sample questions are from this scenario. Tool descriptions and failed tool calls are covered on the MCP mind maps, so this page doesn't repeat them.

Guide §5, scenario 1: “Customer Support Resolution Agent — Agent SDK; custom MCP tools (get_customer, lookup_order, process_refund, escalate_to_human); target 80%+ first-contact resolution with escalation. (D1, D2, D5)”

First, the picture: the loop and where hooks sit

Claude replies Pre-call hook can block the call Tool runs PostToolUse hook cleans the result Result added to the history Done end_turn tool_use

A prompt asks Claude to do something, and it usually does. A hook makes it happen every time, because it's code that runs outside Claude. Many questions in this scenario come down to “ask” or “make”.

The six maps at a glance

#QuestionUsual answerPractise
1When does the loop stop?On stop_reason: continue on tool_use, stop on end_turnstop_reason
2Prompt or hook?Must happen every time, or money is at stake: a hook or a prerequisite gatePrompt or hook
3Tool results come in messy formatsA PostToolUse hook cleans them before Claude sees themHook cleanup
4When should the agent escalate?Explicit criteria and examples. Escalate at once when the customer asks for a humanWho escalates
5Several customers matchAsk for another identifier. Never guessSeveral matches
6Long chats lose exact factsA “case facts” block, trimmed tool results, key facts at the startContext meter

A yellow row in each map is the runner-up: the case where a different answer wins because one fact in the question changes.

Mind map 1: When does the loop stop?

What you seeWhere the fault isFix
The loop stops when Claude's text says “I'm done”It reads the wording, not the signalCheck stop_reason
The loop stops after 5 turns even when work remainsA fixed turn limit is the main way of stoppingStop on end_turn. A limit is only a safety net
stop_reason is tool_use—Run the tool, add the result to the history, and call Claude again
stop_reason is end_turn—Stop and return the answer
The same steps happen every time, in a fixed orderThe model doesn't need to chooseA fixed sequence in code can beat a model-driven loop
Rule: keep looping while stop_reason is tool_use, and stop at end_turn. Never decide from the text, and never use a turn limit as the main way to stop.

Guide 1.1: “Continue the loop when stop_reason == "tool_use"; terminate when "end_turn". Anti-patterns: parsing natural-language signals to determine termination; arbitrary iteration caps as the primary stop; checking assistant text content as a completion indicator.”

Example. A support agent sometimes ends a conversation before the refund is processed, because its reply contains “Let me take care of that”. The loop stops when a reply has no question mark. Best fix?
  1. Tell Claude to always end with “DONE” when finished
  2. Continue while stop_reason is tool_use, and stop on end_turn
  3. Always run at least 5 turns
  4. Check the reply for words like “refund processed”
B. It uses the signal the API gives. A and D still read the text. C is a turn limit, which wastes turns on easy cases and may still cut off hard ones.

Mind map 2: Prompt or hook?

What you seeWhere the fault isFix
In 12% of chats the agent looks up orders before checking the customer's identityThe order is only asked for in the promptA prerequisite gate: block lookup_order and process_refund until get_customer returns a verified ID
Refunds over $500 must never be processed automaticallyA prompt rule fails sometimesA hook on the outgoing call blocks it and routes to escalate_to_human
Someone suggests a stronger system prompt or few-shot examples for a must-never ruleBoth still leave a small failure rateUse code (a hook or gate) for rules that must always hold
It's about tone or style, like “be friendly and brief”A hook can't enforce tone, and slips don't cost moneyA prompt instruction is right here
Rule: if a slip would cost money, break a law or skip a security check, enforce it in code with a hook or a prerequisite gate. Prompts and examples are for judgement and style.

Guide 1.4: “When deterministic compliance is required (e.g., identity verification before financial ops), prompt instructions have a non-zero failure rate. Block downstream tool calls until prerequisites complete.” Guide 1.5: “Hooks give deterministic guarantees vs prompt-based probabilistic compliance. Block policy-violating actions (e.g., refunds > $500) and redirect to escalation.”

Example. Company policy says the agent must never refund more than $500 without a manager. Testing shows the agent follows this 98% of the time. What should the team do?
  1. Put the rule in capital letters at the top of the system prompt
  2. Add five few-shot examples of large refunds being escalated
  3. Add a hook that blocks process_refund above $500 and calls escalate_to_human
  4. Remove process_refund from the agent's tools
C. A hook makes the rule hold every time. A and B raise the 98%, but never to 100%. D works, but it stops small refunds too, which hurts the 80% target.

Mind map 3: Tool results come in messy formats

What you seeWhere the fault isFix
Dates come back as Unix timestamps from one system and ISO 8601 from another, and Claude mixes them upClaude sees raw, mixed formatsA PostToolUse hook converts them to one format first
Status comes back as number codes (3, 7, 12)Claude has to guess what they meanThe hook turns codes into words (“shipped”)
A tool returns 40 fields when 5 matterContext fills up with noiseTrim the result to the fields that matter (the hook can do it)
The problem is in the outgoing call, not the resultA post-call hook runs too lateA hook on the outgoing call (map 2)
Rule: clean results in a PostToolUse hook, before Claude sees them. Asking Claude in the prompt to “convert all dates” is the weaker answer.

Guide 1.5: “PostToolUse hooks intercept results for transformation before the model sees them. Normalize heterogeneous formats (Unix ts, ISO 8601, numeric codes).”

Example. The orders system returns dates as Unix timestamps, and the CRM uses ISO 8601. The agent sometimes tells customers the wrong delivery date. Best fix?
  1. Explain both formats in the system prompt
  2. Add a PostToolUse hook that converts all dates to one format
  3. Add a convert_date tool for the agent to call
  4. Ask the orders team to change their API
B. Claude never sees the mixed formats. A works most of the time, but still asks Claude to convert. C relies on Claude remembering to call it. D might work one day, but it's outside your control.

Mind map 4: When should the agent escalate?

What you seeWhere the fault isFix
The agent escalates easy cases and tries to handle hard policy exceptions itselfThe line between “resolve” and “escalate” is unclearExplicit escalation criteria plus few-shot examples of each
The customer says “let me talk to a person”—Escalate right away
The customer is frustrated, but the fix is simpleEscalating would be slower for themOffer the fix first. Escalate if they still ask for a person
Escalation is routed on sentiment or on Claude's own confidence scoreNeither measures how complex the case isRoute on explicit criteria: policy gaps, exceptions, no way forward
Humans get escalations and have to read the whole chatNo handoff summaryA structured summary: customer ID, root cause, amount, recommended action
Rule: escalate when the customer asks, when the policy has a gap or needs an exception, or when the agent can't make progress. Teach it with criteria and examples, not with sentiment or self-rated confidence.

Guide 5.2: “Triggers: customer requests a human; policy exceptions/gaps; inability to progress. Escalate immediately on explicit demand; offer resolution when straightforward. Sentiment-based escalation and self-reported confidence are unreliable proxies for complexity.” Guide 1.4: “compile structured handoff summaries (customer ID, root cause, refund amount, recommended action).”

Example. Only 55% of chats are resolved on first contact (target 80%). The agent escalates simple refunds but tries to handle warranty exceptions itself. Best fix?
  1. Escalate when the customer's sentiment turns negative
  2. Escalate when Claude rates its confidence below 70%
  3. Write explicit escalation criteria, with examples of cases to resolve and cases to escalate
  4. Train a separate classifier on past tickets
C. The decision line is unclear, so draw it. A and B measure the wrong thing. D could work, but it's far more effort than the problem needs.

Mind map 5: Several customers match

What you seeWhere the fault isFix
get_customer("Priya Sharma") returns three accountsThe agent can't know which oneAsk the customer for another identifier (email, order number)
The agent picks the most recently active accountA guess that will sometimes be wrongNever choose by a heuristic. Ask
Exactly one account matchesNothing is ambiguousGo ahead with that account
Rule: when more than one record matches, ask for something that tells them apart. Picking one by a rule of thumb risks acting on the wrong person's account.

Guide 5.2: “Multiple customer matches → ask for identifiers (not heuristic selection).”

Example. A customer gives only their name. get_customer returns two accounts in the same city. What should the agent do?
  1. Use the account with the most recent order
  2. Ask the customer for their email or an order number
  3. Escalate to a human
  4. Show both accounts' details to the customer and ask which one
B. One more identifier settles it safely. A is a guess. C works, but it's slow for something the agent can sort out. D shows one customer's data to another.

Mind map 6: Long chats lose exact facts

What you seeWhere the fault isFix
After summarizing, “$247.50 refund promised by 5 March” becomes “a refund was discussed”Summaries drop numbers, dates and promisesKeep a “case facts” block with exact values, outside the summary
Details in the middle of a long context get missed“Lost in the middle”Put key facts at the start, with clear section headings
Each order lookup adds 40 fields and the context fills upTool results are kept in fullTrim tool results to the fields that matter
The chat is short and nothing has been summarizedNo facts have been lostNo extra structure needed yet
Rule: keep exact facts (amounts, dates, IDs, promises) in their own block that is never summarized. Put what matters at the start, and trim tool results.

Guide 5.1: “Progressive summarization risks condensing numbers, %, dates, customer expectations into vague summaries. Extract transactional facts into a persistent ‘case facts’ block; trim verbose tool outputs to relevant fields; place key summaries at the beginning + explicit section headers.”

Example. In long chats, the agent forgets the exact refund amount it promised earlier, and later quotes a different figure. Best fix?
  1. Use a model with a larger context window
  2. Keep a case-facts block with the promised amount and date, included in every request
  3. Summarize the chat more often
  4. Ask the customer to repeat the amount
B. The exact figure is kept outside anything that gets summarized. A gives more room, but facts in the middle still get lost. C loses even more detail. D pushes the work onto the customer.

Three traps that catch people

1 · “Improve the prompt” for a rule that must always hold

If the question gives a failure rate (like 12%) for something involving money or identity, the answer is code: a hook or a prerequisite gate. Stronger wording and more examples are the runner-up.

2 · Sentiment and confidence sound smart

Options that escalate on an angry customer or on Claude's own confidence score look sensible, but the guide calls both unreliable. Look for explicit criteria with examples.

3 · Wrong tool picked? That's the MCP page

When the agent calls get_customer instead of lookup_order, the first fix is the tool descriptions. That's MCP map 3. A failed tool call is MCP map 4.

How to study this

  1. Read one mind map, then open its Trap Gym page. Change the setting and watch what happens.
  2. Do the D1 practice questions and D5 practice questions. For each one, say which row of which map decides it.
  3. Print this page and cover the Fix column. Can you fill it in from memory?

Related: Domain 1 hub · Domain 5 hub · Multi-agent mind maps · Extraction mind maps · Claude Code mind maps · MCP mind maps · all traps · CCA-F start here