Orchestrating Claude Models: A Model and Effort Matrix for Lower Cost

Key takeaways

• The Claude price ladder is steep. Per million output tokens, Claude Fable 5.1 costs $50, Opus 5.5 $20, Sonnet 5.5 $10 and Haiku 5.5 $0.50. For the same tokens, that is 100x, 40x, 20x and 1x the cost of Haiku (prompts up to 100,000 tokens).
• Lower the effort before you switch to a smaller model. Effort controls thinking, tool calls and output length within one model. On research and knowledge work Anthropic measured nearly flat curves: medium matched high, and low gave up a few points for a third to a half off. Coding is a real tradeoff, and the highest setting rarely pays.
• Use several agents only when there is bulk to hand off. A frontier "orchestrator" with cheaper workers helps on many independent pieces or on work larger than one context window. On a single dependent chain that fits in one context, the orchestrator's own model at lower effort came out ahead in every case Anthropic measured.
• Multi-agent work multiplies tokens. Anthropic's research system used about 15x the tokens of a chat, and Claude Code agent teams about 7x a normal session. Over-spawning agents, duplicate searches and vague task boundaries are the usual failures.
• Caching and context hygiene are the free savings. Cache reads cost 2.5% to 10% of the input price. Switching model or effort mid-session, changing tools or compacting invalidates the cache.
• Lock down agents that only read. Give a read-only analysis agent no email or document connectors, deny shell commands that read files, and test the rules with dummy "canary" files before trusting them.

How to read the numbers

All facts are stated as of 13 October 2026 and were read on Anthropic's documentation and pricing pages that day, unless marked otherwise. Prices are in US dollars per million tokens. Vendor means a figure read on Anthropic's own pages. Vendor claim marks Anthropic's statement about its own measurements. Secondary marks a non-Anthropic source. Arithmetic marks my calculation from stated figures, and Assumption marks an input I chose. Model background is in Claude and the Top models comparison; wider cost drivers are in Costs and economics.

This page is a stable reference: its structure changes only when Anthropic changes its model line-up, effort controls or agent tooling. Prices on it still move, so check the pricing page before budgeting.

The price ladder: 100x from Haiku to Fable

Anthropic's current models share one 1-million-token context window. Prices differ by tier (Vendor; Anthropic pricing).

Three details change real bills:

• Haiku 5.5 has a long-prompt step. Above 100,000 prompt tokens every Haiku price rises fivefold, so tasks given to a cheap gathering agent should stay small (Vendor).
• Cache writes cost more than plain input. A 5-minute cache write costs 1.25x input and a 1-hour write 2x. A cached prefix pays off from the second request at 5 minutes and from the third at 1 hour (Vendor; Anthropic prompt caching).
• Thinking is billed as output. It is billed even when it is hidden or summarised (Vendor; Claude Code costs).

On the Pro and Max subscription plans, Claude Code usage counts against a 5-hour window and a weekly window shared with the Claude apps, and Max has a separate weekly limit for Fable. If an ANTHROPIC_API_KEY is set, Claude Code bills the API instead of the plan (Vendor; Claude Help Center, Pro and Max plans). On a plan, dollar estimates are a proxy for how fast work uses up those windows.

Effort is the first lever

The effort setting (low, medium, high, xhigh, max) applies to all output: text, tool-call arguments and thinking. It is a behavioural signal, not a hard token budget. Lower effort gives fewer, terser tool calls; higher effort gives more calls, plans and longer summaries (Vendor; Anthropic effort).

Sources: Anthropic effort and Claude Code model configuration. Claude Code defaults Opus, Sonnet and Haiku 5.5 to medium, and its guide says max is "prone to overthinking" (Vendor).

What the curves show (Vendor claim; Anthropic's cost-optimisation guidance and Claude Code model configuration):

• Research and knowledge work: nearly flat. Medium matched high, and low gave up a few points for a third to a half off the cost per task.
• Long-horizon coding: a real tradeoff. Each step down cost a few points of pass rate for a substantially lower cost, and the top settings bought little for a large multiple of the cost.
• Newer models need less effort. Opus 5.5 at medium matches or beats Opus 5 at high on Anthropic's coding and knowledge-work evaluations.
• Low effort on Haiku has a cost. It risks skipped searches, early stops and skipped checks in long agent prompts (Vendor).

Anthropic publishes no per-level token percentages, so measure on your own tasks. Re-run failures instead of paying for high effort everywhere: run at a low setting, let a test or checker find the failures, and re-run only those at a higher setting. In Anthropic's coding runs this held the pass rate of running everything high, for a little over half the cost (Vendor claim).

When several agents beat one

Anthropic's own evidence draws a clear line:

• Wide, parallel reading pays. In its multi-agent research system, an Opus lead with Sonnet subagents beat a single Opus agent by 90.2% on an internal research evaluation. Token use explained about 80% of the performance variance. The system used about 15x the tokens of a chat, so Anthropic recommends it only when the task's value covers the cost, and calls it a poor fit for most coding and for tasks that need one shared context (Vendor claim; Anthropic, multi-agent research system).
• Start simple. Anthropic's agent guidance recommends the simplest pattern that works: routing easy inputs to cheaper models, orchestrator-workers only when the subtasks cannot be predicted in advance, and agents only when the flexibility is worth "higher costs and the potential for compounding errors" (Vendor; Anthropic, Building effective agents).
• The advisor pattern can pay. A cheap executor that consults Opus only at hard decisions raised Sonnet's SWE-bench Multilingual score by 2.7 points at 11.9% lower cost per task. With Haiku as the executor, its BrowseComp score rose from 19.7% to 41.2%, still below Sonnet alone (Vendor claim; Anthropic, The advisor strategy).
• Many readers, one writer. Parallel agents that cannot see each other's work produce conflicting edits. Multi-agent reading with a single writing thread works (Secondary; Cognition, Don't Build Multi-Agents).
• Cheap routing is old evidence, but consistent. Outside Anthropic, the RouteLLM router cut cost by more than 85% on MT Bench while keeping about 95% of GPT-4's quality (Secondary; LMSYS, RouteLLM), and the FrugalGPT cascade reported up to 98% savings in its best case (Secondary; FrugalGPT paper).

In Claude Code, subagents can set their own model and effort in their definition. Each fresh subagent starts its own cache prefix with a 5-minute lifetime, and detailed results flow back into the parent's context. A "fork" reuses the parent's cache and costs less than a fresh subagent for side tasks that need the current conversation (Vendor; Claude Code subagents; Claude Code prompt caching).

A model and effort matrix

This matrix turns the evidence above into defaults for a team working in Claude Code. It is my synthesis (Assumption), not an Anthropic recommendation. Tune it against your own measurements.

The chart assumes four reads of 100,000 tokens each, so each stays at Haiku's lower price step, plus 4,000 output tokens; thinking and tool overhead are left out (Assumption; Arithmetic). Real jobs vary, but the ratio holds: gathering on Haiku costs about a fortieth of doing it in an Opus session.

Context and caching hygiene

• Clear between unrelated tasks. Use /clear, and use /compact with a short focus sentence when context grows. Keep CLAUDE.md under about 200 lines and move workflows into skills, which load only when used (Vendor; Claude Code costs).
• Know what breaks the cache. Switching model, changing effort on most models, toggling fast mode, adding or removing tools and compaction all invalidate the cache. Claude Code keeps the main conversation's cache for 1 hour on subscription plans and 5 minutes with an API key; subagents default to 5 minutes (Vendor; Claude Code prompt caching).
• Load connectors only when used. Claude Code can stop loading claude.ai connectors with the disableClaudeAiConnectors setting; the connection stays on the claude.ai account. A per-server toggle is available under /mcp (Vendor; Claude Code MCP).
• Cap scripted runs. Headless runs (claude -p) take --max-budget-usd and --max-turns. The budget is a client-side estimate that subagents count towards and that can overshoot, so leave headroom. --output-format json reports the estimated cost per model (Vendor; Claude Code CLI reference).
• --bare needs an API key. It skips hooks, skills, CLAUDE.md and MCP servers, but it never reads the subscription login, so it suits API-key automation only (Vendor; Claude Code CLI reference).

Lock down read-only analysis agents

A read-only analysis run (a code audit, for example) should load as little as possible and touch nothing:

• Remove what it cannot use. Run without MCP servers and skills (for example --strict-mcp-config and --disable-slash-commands) so no email, drive or calendar tool sits in its tool list. Grant only file reading and writing inside its own output folder.
• Name the helpers. Pass the cheap gathering agent explicitly with --agents, and tell the model not to use built-in agents, which run on the parent's (expensive) model.
• Do not trust file deny rules alone. In tests on Claude Code 2.1, read-only shell commands were allowed automatically inside the working folder. A recursive grep there returned the contents of files that a Read deny rule blocked, while the built-in Grep tool respected the rule. Denying shell readers explicitly (cat, grep, rg, head, tail, sed, awk, find, sort, git show, git diff and similar) closed the gap (Assumption: one observed test with dummy files, not an Anthropic statement).
• Test with canaries. Put dummy files with secret-like names and a marker string in the working folder, run the agent without its usual instructions, and confirm that the marker never appears in the output.

What this means for your business

These points are inferences from the evidence above, not sourced forecasts.

1. Default to one capable model at medium effort. Move to several agents only for bulk reading or work that does not fit in one context.
2. Send reading to the cheapest tier and keep judgement in the strongest. Give gathering agents one question, a length cap and a demand for sources, so their output is short enough to trust and check.
3. Measure cost per finished task, not per request. A cheap request that needs retries is not cheap. Log turns and cost per run, and retune after a few runs.
4. Treat the top tier as a specialist. Use Fable-class models for rare, high-value analysis with a written brief and a human go-ahead, not as the everyday default.
5. Write the security rules before the agent runs. Remove send-capable connectors from agents that only read, deny shell readers, and test with canary files.
6. On a subscription, budget usage windows, not dollars. Keep API keys out of the environment unless you mean to pay per token.

Open questions and unverified items

• The Sonnet 5.5 cache-read price was read as $0.10 on the pricing page; an Anthropic reference cached on 6 October lists $0.20 (open-question).
• Anthropic does not publish the sizes of the Pro and Max usage windows (open-question).
• Anthropic publishes no per-level token percentages for effort, only per-workload curves (open-question).
• The shell-reader behaviour above was observed in one Claude Code version and may change (unverified).

Sources

1. Anthropic pricing
2. Anthropic prompt caching
3. Claude Code costs
4. Claude Help Center, Pro and Max plans
5. Anthropic effort
6. Claude Code model configuration
7. Anthropic, multi-agent research system
8. Anthropic, Building effective agents
9. Anthropic, The advisor strategy
10. Cognition, Don't Build Multi-Agents
11. LMSYS, RouteLLM
12. FrugalGPT paper
13. Claude Code subagents
14. Claude Code prompt caching
15. Claude Code MCP
16. Claude Code CLI reference