A cheaper model won't necessarily cut your Claude Code bill

In October, one user reported (without sharing data) that their monthly bill fell from $1,940 to $460 after they split work across several models and had a script run the test suite instead of a model. That same month, a different test found the opposite: adding an Opus advisor to a cheap-model workflow pushed the bill up, while the Haiku part cost just 3 cents.

These results don't actually contradict each other. Both say the cost sits in which tasks end up running on the expensive model. On top of that, three things move the bill in ways a per-token price list won't show you: context that gets re-read, the effort setting (how much the model is allowed to deliberate on each task), and retries.

If you use Claude Code to fix themes or build sections, those are the places to check before you switch models.

The Opus advisor re-reads the whole conversation with no cache

One user tried a three-model setup on a single bug fix: Sonnet 5.5 as the main model, Opus as advisor, Haiku as a subagent (a helper running in its own session). The full stack cost $1.37, against $1.14 for Sonnet 5.5 alone. The Opus advisor accounted for 54% of the bill; Haiku cost 3 cents. According to the tester, every advisor call re-read the entire conversation without cache (the mechanism that bills already-read context at a lower rate), so one call of more than 100,000 tokens came to $0.40 in Opus input by itself. Their takeaway is that the real lever is how much work moves off Opus.

SSkaly_Bull@Skaly__Bull

Your Claude Code bill is not a Haiku problem
It is an Opus problem

The viral three-model stack got tested on one bug fix
Sonnet main, Opus advisor, Haiku subagents: $1.37
Plain Sonnet 5.5 on its own: $1.14
The Opus advisor ate 54% of that bill, Haiku cost 3 cents

Every advisor call rereads the whole transcript with no cache
One call over 100K tokens is $0.40 of Opus input

The 75% everyone quotes is Haiku 5.5 vs…

Oct 12, 2026 · View on X

Subagents have a similar trap. One user points out that a subagent's cache expires after 5 minutes of inactivity. If it waits on a test run or a build for longer than that, the next step has to reprocess the whole context, and that reprocessing counts more heavily against your usage limits. A 1-hour cache avoids this, but the same user cites the official docs: at API prices, writing a 1-hour cache costs 2x the base input price, versus 1.25x for a 5-minute cache. That's why they recommend turning on the 1-hour cache only for subagents that tend to wait, not for every subagent.

The same post flags a threshold worth knowing for 1-million-token context models like Opus 5.5: by default Claude Code only compacts the conversation at around 967,000 tokens, so until then every message carries the entire conversation with it. The /autocompact 400k command moves that compaction point earlier.

A short rule set saves the most at the highest effort

The author of Occam, a 30-line rule set for coding agents (read only what's needed, reuse existing code, keep answers short), published their own results from 18 coding tasks, run over five rounds on three models. Compared with no rule set, Sonnet 5.5 at the highest effort cut estimated cost by 55%, based on the list prices Claude Code reports, and passed 17 of 18 checks versus 16 without the rules, a one-task difference. At medium effort, Sonnet's saving was only 3%, and the 95% confidence interval still included zero, meaning the saving wasn't proven. For Opus 5.5, the cut was 51% at the highest effort and 11% at medium. The project's own README says the results only hold for these tasks and can't be generalized to every model or every project.

In this test, the biggest savings showed up at the highest effort; at medium they were much smaller.

A stronger model can be cheaper per finished task

An analysis of Sonnet 5.5 and Opus 5.5 argues that Sonnet is cheaper per run, but Opus can still be cheaper per finished task, because the difference comes from effort, cache misses, and paid runs that didn't produce a result.

Rrari@0xwhrrari

Sonnet 5.5 is cheaper per run

Opus 5.5 can still be cheaper per finished task

The difference is in effort, cache misses and the retries you paid for but never shipped

I broke down when to use each model and how to measure what the job actually costs ↓ https://t.co/sPjFexZrZl

Oct 3, 2026 · View on X

Going by the price table the author dated October 3, Sonnet 5.5 costs $2 per million fresh input tokens and $10 per million output tokens, Opus 5.5 costs $4 and $20, and cache reads are $0.20 for both. After that, Anthropic announced it was halving Sonnet 5.5's cache-read price to $0.10, which makes Sonnet roughly 20% cheaper on most agentic work. The change applies only to the API; Claude Code usage limits stay the same.

So we think the better metric is total spend across every run, failed ones included, divided by the number of tasks that pass the check you set. The analysis suggests using the same test that would block a merge as the bar, and looking at hard tasks separately.

Its example: if the cheapest tier handles 90% of requests but burns half the budget on the remaining 10%, the average can hide that.

Before optimizing, check which model is actually running

If you don't set a model for a subagent, it uses the main session's model, according to a guide on moving subagents to a cheaper model. The built-in Explore subagent does the same. The guide lists Opus 5.5, the default main model, at $4 and $20 per million tokens, and Haiku 5.5 at $0.10 and $0.50 for requests under 100,000 tokens, roughly a 40x gap in token price. For longer requests, Haiku 5.5's price is five times that.

The same guide cites a bug report on the Claude Code repo: versions 2.1.283 through 2.1.290 ignore the model: haiku line in subagent config, and the reporter found that 279 of 301 runs still used Opus 5.5.

Measure on your own work

Pick a repeat task, say editing a theme section to the same brief for several clients, run it a few times, and record the total cost, failed runs included. Then change one variable at a time: model, effort level, cache duration, and recompute the cost per finished task. Occam's README also recommends repeated runs to measure your own work.

The user who reported going from $1,940 to $460 also made clear that an agent team uses more tokens than a single session, and that the savings came from giving the right task to the right model, plus a test step run by code. A price list tells you what one token costs; what a finished task costs is something only measuring your own work can answer.