The discount came out of the checking

The prompting guide for Anthropic's cheapest model reads, in places, like an inventory of things it will decline to do. At low effort, Claude Haiku 5.5 "is more likely to skip a search, stop early, or skip a check." At low and medium effort it "sometimes reports a code change as done without running a check." Given a long coding-agent system prompt at low, "it sometimes stops early and hands the task back to the user." These are not open bugs with fixes pending. They are a published description of what the cheap setting is.

Haiku 5.5 arrived on 7 October as, by Anthropic's description, "the cheapest, fastest, and most capable small model we've ever released," and as "our first Haiku-class model to come with an adjustable effort setting." Five levels, low through max, with medium as the default. Input runs at $0.10 per million tokens and output at $0.50, against $1 and $5 for Haiku 4.5: 90% lower for prompts up to 100,000 tokens, and around 75% less on average once longer requests and a slightly hungrier tokeniser are accounted for.

The discount is real. What it buys is less obvious than it looks, because on this tier the dial does not trade quality for money in the way the word "effort" suggests. It trades steps. The first things it stops paying for are the search that would have found the current fact, the continuation that would have finished the job, and the check that would have caught the mistake. Which means the correct response to a 90% price cut on the small tier is to raise the setting, not to pocket the saving.

What the dial actually moves

Start with the mechanism, because the name is misleading. On Haiku 4.5 you controlled reasoning with a thinking budget, budget_tokens, a number of tokens set aside for the model to think in. Effort replaces it, and it is a different kind of object. The documentation is explicit: "Effort is a behavioral signal, not a strict token budget." Nothing is reserved and nothing is capped. The level shifts the model's disposition toward spending tokens at all, and it "affects all tokens in the response," which the page enumerates as text, thinking, and tool calls with their arguments.

That last item is where a cost control becomes a behaviour control. Lower effort, the page says, means "fewer and terser tool calls," operations combined into one call, action without preamble, terse confirmations at the end. In a chat reply, that reads as welcome brevity. In an agent loop, a tool call is not prose. It is an action: a web search, a file read, a test run, a type-check. Fewer tool calls is fewer actions taken on the world before the model commits to an answer. The dial does not make the answer read worse. It shortens the procedure that produced it, and the procedure is not what comes back.

Anthropic has measured the exchange rate and published it, which is rarer than it should be. In its testing, moving from low to medium "roughly halved early stopping. It also more than doubled the output tokens for each attempt." Read that as a price: on this model, halving one failure mode costs upwards of twice the generated tokens.

Then do the arithmetic the launch post does not do for you. Suppose an agent turn at low emits 8,000 output tokens across its thinking, tool calls and final report. At $0.50 per million that is $0.004. Double it to 16,000 tokens at medium and you pay $0.008. The same 8,000 tokens on Haiku 4.5, at $5 per million, cost $0.040. So the setting that halves early stopping costs twice the cheapest setting of the new model and still a fifth of the cheapest setting of the old one. The figures are illustrative, since Anthropic gives the token increase as a ratio rather than an absolute, but the gap is wide enough that the direction is not in doubt. The price cut is large enough to absorb the dial twice over. Taking the whole discount in cash is the one allocation that converts a price cut into a reliability cut.

Where the skipped steps go

The launch post recommends Haiku 5.5 for "compaction, summarization, or subagent work." Those three roles have something in common that matters more than their cost: their output is consumed by another model as a premise rather than read by a person as a claim.

A subagent that skipped a check does not return a shorter answer. It returns a confident paragraph saying the work is done, which the orchestrator appends to its context and reasons from. A compaction step that stopped early does not announce the omission; it hands up a summary that is simply missing a fact, and nothing downstream knows the difference between a context that was compressed and one that was truncated. The failure is not a wrong sentence. It is a true-looking sentence with an unperformed action behind it, and the place the cheap tier is recommended for is exactly the place where nobody is positioned to notice.

The second control has the same shape. Task budgets, in beta on Haiku 5.5, let you give the model a token allowance for a whole agentic loop, with a minimum of 20,000. The model "sees a budget-countdown marker injected server-side" and paces itself against it, and adaptive thinking "scales down as the budget depletes." The countdown, though, is "visible only to the model": there is no remaining-budget field in the response, no accessor in the SDK. Set one too small and the documented result is that the model "may decline to attempt the task at all, scope it down aggressively, or stop early with a partial result." Both of the levers that govern how much work gets done are therefore invisible in the artefact that comes back. You can read the answer. You cannot read the budget it was written under.

This only became a live problem this month. On Terminal-Bench 4.0, Haiku 4.5 scored 0.0%; Haiku 5.5 scores 39.2%, against 70.6% for Sonnet 5.5. On OSWorld's offline subset, 15.7% became 72.4%. A model that completed none of the agentic coding tasks was never trusted with a long loop, so the question of which steps it quietly omitted did not arise. Now the cheap tier clears a third of them, cheaply enough to run constantly, and the question is load-bearing.

The price bends the wrong way at length

There is one more gradient, and it points the same direction. Haiku 5.5 is priced by prompt length. Above 100,000 input tokens every category multiplies by five: input $0.50, output $2.50, cache reads $0.05 instead of $0.01. The threshold "counts all of its input tokens, including cache reads and cache writes," and "each request is priced on its own." Among models from Claude 4.6 onward, Haiku 5.5 is the stated exception to flat pricing across the full context window.

In an agent loop, context grows monotonically until something compacts it. So the moment a task turns long is the moment its per-token price quintuples, and that is the same moment at which early stopping and unperformed checks do the most damage. Cost pressure and reliability pressure both push toward fewer steps, together, at the hardest part of the task. The model whose job description includes keeping other models' windows small is itself five times cheaper while its own window stays small.

The case for the other reading

The strongest objection is that all of this is the product working as designed, and documented in public. The default is medium, not low. Anthropic ships remedies with measured effects: a dated system-prompt paragraph that raised the search rate on questions whose answers had changed while adding searches on only 0 to 3 percent of prompts that needed none, and a verification paragraph with which, it reports, "the model checked its changes more often with this text, and its performance improved, at the cost of more tokens." It even warns against the obvious overcorrection, reporting that a blanket instruction to always search made the model search on half the prompts that needed no search and "didn't produce more correct answers." The launch post plots accuracy against cost per attempt for all five effort levels. Most vendors publish a price and a score.

All true, and it is why this piece can be argued at all. But notice what travels. The artefacts that reach a procurement spreadsheet are the price per million tokens and one number per benchmark row, and that row does not state the effort level it was run at; only a single Sonnet figure in the table carries a level at all. And the remedies are themselves the admission. The documented fix for a skipped check is a paragraph of system prompt that costs more tokens, which is to say: buy the verification back with the money you just saved.

One limit worth stating plainly. Everything above is one company's documentation of its own model, read from an environment where the equivalent pages from other labs were not reachable. Treat it as a claim about Haiku 5.5, not a measured comparison between vendors.

What to do with it is concrete. Run your evals at the effort level you will actually deploy, and run them fresh: the guidance for every recent model says levels were recalibrated and old settings should not be carried over. Score trajectories, not just answers, because a final-answer eval cannot see a step that did not happen; count the searches, the tool calls, and whether the check actually ran. Log the 100,000-token boundary as an event, not a line item. And when a provider halves a price on the tier you run in volume, decide explicitly how much of that you are giving back to the dial, because the default is to give back none.

The old failure mode was an answer that was wrong. The one the cheap tier introduces arrives on time, under budget, and says it ran the tests.