Why most agents default to the wrong Claude tier

Anthropic’s current stack is four tiers, and the choice is an economics problem, not a benchmark one. Most teams default to Opus for everything because it tops the benchmarks, or stay on Sonnet out of habit - and pay the wrong rate for most steps of an agent workflow either way. Fable 5.1 (claude-fable-5-1, $10 / $50 per million input/output tokens) is the frontier escalation tier for the hardest reasoning and longest-horizon work. Opus 5.5 (claude-opus-5-5, $4 / $20) is the orchestrator - 20% cheaper per token than Opus 5 and 2.5x cheaper than Fable. Sonnet 5.5 (claude-sonnet-5-5, $2 / $10) is the default daily driver. Haiku 4.5 (claude-haiku-4-5, $1 / $5) is the worker you fan out across parallel sub-agents. Match the tier to the job and you stop paying Fable or Opus rates for work Haiku finishes faster.

Definitions

Fable 5.1 - Anthropic’s frontier tier (claude-fable-5-1), highest widely available capability, built for the hardest reasoning and longest-horizon agentic work. Successor to Fable 5 at the same per-token price, with cache reads cut to $0.25 per million. Ships with safety classifiers that can decline a request as an HTTP 200 with stop_reason: "refusal". See Claude Fable 5: refusals are an API contract, not an error for the refusal contract it inherits.

Opus 5.5 - Anthropic’s orchestrator-tier model (claude-opus-5-5), successor to Opus 5 at a lower price. 1M-token context, up to 128K output tokens. Thinking is always on - effort is the only control, and it defaults to medium, one level below Opus 5. Background on the line: Claude Opus 5 closes on Fable at Opus price.

Sonnet 5.5 - the default worker tier (claude-sonnet-5-5), successor to Sonnet 5 at the same price and with the same tokenizer. 1M-token context, adaptive thinking, effort default high with recalibrated levels. Background on the line: Claude Sonnet 5 closes the gap to Opus without the Opus bill.

Haiku 4.5 - the fast, cheap tier for high-volume and latency-sensitive work. 200K-token context, 64K max output. Built to run as a sub-agent under a more capable orchestrator.

The tiers at a glance

Prices, context windows, and output caps are from Anthropic’s pricing and model documentation, current as of 2026-09-30. The effort parameter is Opus-, Sonnet-, and Fable-tier only - it returns an error on Haiku 4.5, so Haiku is configured through the older thinking controls, not effort. The two rows that changed most with the 5.5 generation are refusals and forced tool use: every tier above Haiku now declines some requests as a successful HTTP 200 with stop_reason: "refusal", and none of them accepts a forced tool call - use tool_choice: "auto" with strict: true tools or structured outputs instead.

The price gap shrinks on cached tokens

The list prices say Opus 5.5 costs twice Sonnet 5.5 and Fable 5.1 costs 2.5x Opus. That holds for fresh input and output. It does not hold for cache reads, where the whole stack sits between $0.10 and $0.25 per million - and Opus 5.5 reads cache at exactly Sonnet 5.5’s rate.

That matters because agent loops are mostly cache reads: every turn resends the growing history, and a 2026 study of provider-billed Claude Code runs (arXiv 2607.12161) found cache traffic made up about 87% of spend. Illustrative arithmetic for one agent turn with a 50K-token cached prefix, 2K fresh input tokens, and 1K output tokens:

On a cache-heavy turn, Opus 5.5 costs about 1.6x Sonnet 5.5, not 2x, and Fable 5.1 about 2.2x Opus 5.5, not 2.5x. Output is now what separates the tiers. The escalation to Opus is cheaper than the list price suggests on long, well-cached sessions - and more expensive than it looks on short, output-heavy calls. This is arithmetic on list prices, not a benchmark; your split between cached, fresh, and output tokens decides the real ratio. Two caveats: cache is model-scoped, so switching tiers mid-session pays a fresh write on the new model, and Haiku 4.5 only caches prefixes of 4,096 tokens or more (see prompt cache floors).

Pick by job, not by benchmark

Benchmark deltas between tiers are real but they are not the decision. The decision is which role the model plays in your workflow and what that role costs per token. Four roles:

The expensive mistake is running every step at Fable or Opus rates. The other expensive mistake is forcing a deep, long-horizon migration through a tier that loses the thread halfway. Tier selection is the lever; the sections below are when to pull it.

Encoded as a config your scripts and sub-agent launchers can read:

FRONTIER=claude-fable-5-1      # rare, hardest-step escalation only (was claude-fable-5)
ORCHESTRATOR=claude-opus-5-5   # long-horizon, high autonomy (was claude-opus-5)
DEFAULT=claude-sonnet-5-5      # daily driver (was claude-sonnet-5)
WORKER=claude-haiku-4-5        # parallel sub-agents

When to reach for Fable 5.1

Fable 5.1 is still the top widely available rung. Reach for it only for the single hardest step in a run: the one piece of reasoning or the one long-horizon call where Opus 5.5 isn’t enough. At $10/$50 it costs 2.5x Opus 5.5 on fresh tokens, and on a cache-heavy turn still about twice as much. Its cheaper cache reads ($0.25 instead of Fable 5’s $1.00) make long Fable sessions far less painful than before, but they do not change the escalation logic. Every call needs to branch on stop_reason: "refusal"; wire a fallback (Anthropic’s server-side fallbacks parameter handles it on the Claude API) rather than letting the run stop. Full detail on the refusal contract: Claude Fable 5: refusals are an API contract, not an error.

When to reach for Opus 5.5

Reach for Opus 5.5 when the task is long-horizon, hard to fully specify up front, and expensive to get wrong: a multi-day refactor, a codebase-scale migration, or an orchestrator that delegates to a fleet of workers and has to keep the plan straight across hundreds of tool calls. Swapping claude-opus-5 for claude-opus-5-5 cuts the per-token bill 20% and the cache-read bill 60%. Anthropic reports that on many coding, analysis, and vision tasks Opus 5.5 at its default effort matched or beat Opus 5 while using fewer tokens.

Three operational notes:

• Set effort explicitly. Opus 5.5 defaults to medium, one level below Opus 5’s high. For the long-horizon work that justifies Opus, give it the whole spec up front and run at high or xhigh. Thinking cannot be disabled on Opus 5.5; lower effort is the only way to spend less.
• Handle refusals. Opus 5.5’s classifiers are broader than Opus 5’s: bio and reasoning_extraction join cyber. Branch on stop_reason: "refusal" and enable a fallback.
• Fast mode is an Opus-tier lever. When latency matters, Opus 5.5 runs the same model at up to 2.5× output speed at twice the base price ($8/$40), on the Claude API only - a knob Sonnet and Haiku don’t have.

When Sonnet 5.5 is the right default

Sonnet 5.5 is the model you should reach for first and escalate from only with a reason. It carries the same 1M-token context as Opus, the same tokenizer as Sonnet 5 (token counts don’t change on the swap), and Anthropic expects existing Sonnet 5 prompts to perform well without changes.

Pricing is simply $2 / $10. Sonnet 5 launched at that rate as an intro price with a planned rise to $3 / $15 on 2026-09-01; the rise did not happen, and Sonnet 5.5 kept the same rate. Two migration details matter for cost. Effort levels are recalibrated - Anthropic suggests starting at medium for agentic coding and multi-step tool use and low for chat, then measuring. And the minimum cacheable prefix dropped from 1,024 to 512 tokens, so short system prompts that never cached on Sonnet 5 now do.

Stay on Sonnet 5.5 for interactive coding, document Q&A, and design-heavy frontend work. Escalate to Opus 5.5 when the task is long-horizon or autonomy-critical, or when you find yourself pushing Sonnet to xhigh and max to get there - and remember that a bigger window is not what makes the harder tier worth it. The discipline that actually keeps agents reliable is context engineering, and it applies at every tier.

When Haiku 4.5 wins

Haiku 4.5 is the sub-agent economy. At $1 / $5 it costs half of Sonnet 5.5’s rate, and on Anthropic’s numbers it lands 73.3% on SWE-bench Verified while matching Sonnet 4-class coding and computer-use quality at up to 4–5× the speed of Sonnet 4.5. That combination - cheap, fast, capable enough - is exactly what a parallel worker needs. It is also the only tier here without safety-classifier refusals and with forced tool_choice still available, which keeps simple extraction workers simple.

Use it for real-time chat, high-volume classification and extraction, and any architecture that fans many scoped tasks out at once. The one constraint to design around: Haiku’s context window is 200K, not 1M, so keep each worker’s job small and self-contained rather than handing it a sprawling history.

The orchestrator–worker pattern

The tiers compose. The pattern that gets the most out of the stack is an Opus 5.5 orchestrator that delegates scoped sub-tasks to Haiku 4.5 workers, with Sonnet 5.5 as the solo default when no orchestration is needed, and Fable 5.1 called directly for the rare step that needs it. That is worker-tier routing.

Symptom - a single big model reads a 30K-token API reference or a pile of source files, and that clutter stays in context for the rest of the run, dragging quality down. Cause - heavy reads done in the main loop persist on every subsequent turn. Solution - push the read into a sub-agent that runs in its own window and returns only the conclusion. Spawn those workers on Haiku and you get the isolation and the cheapest possible token rate for the grunt work. See subagent context isolation.

This is why the per-token spread matters more than the benchmark spread: in a fan-out architecture, the worker tier runs far more fresh tokens than the orchestrator, so a cheaper worker is a cheaper bill on the dominant cost - and that spread runs as high as 10:1 (Fable 5.1 to Haiku 4.5). The orchestrator’s own long history, by contrast, is mostly cache reads, where Opus 5.5 now pays the Sonnet rate.

Bottom line

There is no single best Claude model - there is a best model per role. Default to Sonnet 5.5, escalate to Opus 5.5 for long-horizon and high-autonomy work, reserve Fable 5.1 for the single hardest step in a run, and delegate the parallel grunt work to Haiku 4.5. Pick by the job and the token bill, not the leaderboard, and the stack pays for itself. Tiering is one lever on that bill - prompt caching and batch processing are the two with a fixed, guaranteed discount. When the choice is openness and hosting rather than Claude tier, use Open-weights ≠ open-source for agent stacks.