CCDV-F Glossary - Model Selection & Optimisation

Quick-lookup definitions for every domain, with exam context and links back to the lesson that covers each term.

Model Tier Spectrum: Claude's four current models - Haiku 4.5 (fastest/cheapest), Sonnet 5 (balanced production default), Opus 5 (frontier reasoning for complex agentic/coding work), and Fable 5 (Anthropic's most capable widely released model) - sit on one speed/cost/intelligence spectrum. A model choice is a point on that spectrum picked *per task*, not a single best model used everywhere.; Exam context: The exam rewards matching a tier to task difficulty and volume, not defaulting to the newest/most capable model for everything. A common distractor frames a higher tier as a strict upgrade; in fact each tier also carries different behavioral defaults and constraints (see Tier-Specific API Behavior), so "most capable" isn't automatically "correct choice."; See also: 2.1 Claude Model Family and Trade-offs
Refusal (stop_reason: "refusal"): On Fable 5 and Opus 5, a safety classifier can decline a request while still returning an ordinary HTTP 200 response, with stop_reason set to "refusal" and details in stop_details. It is a normal response state to branch on, not an HTTP error.; Exam context: Exam scenarios test whether you check stop_reason before indexing into content - code that assumes content[0].text always exists will crash or silently mishandle a declined request on these tiers.; See also: 2.1 Claude Model Family and Trade-offs
Tier-Specific API Behavior: Beyond price, Claude's tiers differ in actual API behavior: Fable 5 runs extended thinking always-on and cannot disable it; Opus 5 allows explicit thinking disable only at effort high or below; Fable 5 requires 30-day data retention and is unavailable under zero-data-retention (ZDR); and Opus 5 has its own separate rate-limit bucket from the older Opus 4.x pool.; Exam context: A common trap assumes every model shares identical defaults and configuration options. Code tested against one tier's defaults (e.g. thinking off by default) can silently misbehave when pointed at another tier.; See also: 2.1 Claude Model Family and Trade-offs
Token Buckets: A request's cost is the sum of up to four separately-priced buckets reported in usage: regular input (input_tokens, full input rate), cache write (cache_creation_input_tokens, ~1.25x input rate at 5-min TTL or ~2x at 1-hour TTL), cache read (cache_read_input_tokens, ~0.1x input rate), and output (output_tokens, roughly 5x the input rate).; Exam context: Exam questions test whether you know caching isn't free (writes cost a premium, reads cost a discount, not zero) and that output is the most expensive bucket per token - trimming a rambling response is usually a bigger lever than trimming similarly-sized input.; See also: 2.2 Token Economics: Counting, Budgeting and Pricing
max_tokens (Hard Ceiling): An enforced per-response output cap that the model itself is never told about. Hitting it truncates the response mid-thought (stop_reason: "max_tokens") - a failed attempt, not a cost saving, since a capped run still spends tokens without producing a usable result.; Exam context: A classic distractor treats max_tokens as a cost or thoroughness control. It's neither - it's a safety backstop against runaway output. The actual cost/thoroughness levers are prompt concision, caching, and (Lesson 2.4) effort/task budgets.; See also: 2.2 Token Economics: Counting, Budgeting and Pricing
Token Counting Endpoint (count_tokens): messages.count_tokens returns an exact input token count for a given system/messages/tools payload without running inference - useful as a pre-flight cost estimate or to sanity-check a prompt change before it ships.; Exam context: The exam distinguishes this exact, no-inference count from guessing at cost via character or word counts, which don't map cleanly to tokens. Also tested: report reads from the Usage and Cost Admin API likewise cost no tokens, since they aren't inference calls.; See also: 2.2 Token Economics: Counting, Budgeting and Pricing
Four-Factor Decision Framework: A model-selection framework built on four questions: task difficulty (does this step genuinely need multi-step reasoning or nuanced judgment?), latency budget (how long will something tolerate waiting?), volume (how many times does this run - the multiplier on any per-call price gap?), and cost of a wrong answer (what does an error cost downstream?).; Exam context: Scenario questions usually hinge on identifying which single factor dominates, since the four don't always point the same direction - e.g. a low-volume but unreviewed, high-stakes step is decided by cost-of-error, not volume.; See also: 2.3 Choosing a Model for a Task
Stepping-Down Method: The disciplined order for finding cost savings once a tier is provisionally chosen: sweep effort on the current tier against an eval set first; only if that's exhausted, drop to the next tier down, confirm its supported parameters, reset effort to that tier's own default, and re-sweep - one notch at a time, never several changes at once.; Exam context: A common distractor jumps straight to the cheapest tier, or judges a keep/revert decision from a single test run. The exam wants effort exhausted before a tier change, and repeated trials against a fixed eval set - a task or two of difference on one run is noise.; See also: 2.3 Choosing a Model for a Task
Effort Parameter (output_config.effort): A per-request setting (low, medium, high, xhigh, max) that scales both thinking depth *and* tool-call behavior together - lower effort means fewer, more-consolidated tool calls and terser output, not just shorter reasoning.; Exam context: The exam expects you to know effort's accuracy/cost curve must be measured per workload: near-flat on research/knowledge tasks (low effort often nearly as good), a real trade-off on long-horizon coding/agentic work, and still-climbing on tasks near a model's reasoning ceiling. Also tested: changing effort mid-conversation invalidates the prompt cache.; See also: 2.4 Effort and Thinking Budget as Optimisation Levers
Task Budget: A beta, advisory, token-denominated ceiling for an entire agentic loop (not a single response) - the server injects a countdown the model can see, so it paces itself and tries to land within budget rather than being cut off. Has a floor of 20,000 tokens and requires streaming; changing it mid-task invalidates the cache.; Exam context: Distinguish from max_tokens: a task budget is advisory and model-aware (self-pacing across turns), while max_tokens is an enforced, model-blind per-response ceiling. A very tight task budget can meaningfully hurt pass rate.; See also: 2.4 Effort and Thinking Budget as Optimisation Levers
Thinking-Disabled Tool-Call Leak: A specific failure mode on models where thinking is on by default (e.g. Opus 5): explicitly disabling thinking to save cost can cause the model to occasionally write what should be a tool call into visible text instead of a proper tool_use block - the turn completes with no error, but the intended tool call never runs.; Exam context: A trap answer disables thinking outright to cut cost. The exam-correct fix is lowering effort instead, which achieves a similar saving without this silent agentic-loop failure.; See also: 2.4 Effort and Thinking Budget as Optimisation Levers
Free Wins vs. Trade-off Levers: Cost techniques split into two categories applied in order: free wins (prompt caching, the Batches API, input-token hygiene) lower cost without lowering quality and are applied first, left on permanently; trade-offs (effort/task budgets, model tier, multi-model architectures) exchange cost for capability and are reached for only after free wins are exhausted, validated against an eval set each time.; Exam context: The exam consistently penalizes an answer that reaches for a model downgrade before caching, batching, or input hygiene are in place - that gives up capability that wasn't necessary to give up yet.; See also: 2.5 Cost Optimisation Techniques
Advisor Pattern: A two-model architecture where a cheaper model runs the main loop and consults a stronger model only on genuinely hard decisions it flags for escalation.; Exam context: The exam tests the fragile condition this depends on: it pays off only when the capability gap is wide *and* the cheap model reliably recognizes when to escalate - a weak escalation signal can make the pairing worse than just using the strong model alone.; See also: 2.5 Cost Optimisation Techniques
Orchestrator Pattern: A two-model architecture where a strong model plans and delegates bulk, independent sub-tasks to cheaper worker models.; Exam context: Only pays off when there's genuine bulk fan-out of independent work; for a single dependent chain of work, one model at well-tuned effort usually beats the overhead of planning, delegating, and merging results - a common distractor assumes orchestration is always cheaper.; See also: 2.5 Cost Optimisation Techniques