How do I split work across frontier and small AI models to cut cost without losing quality?

October 21, 2026 · 6 min read

SentX SI

The answer is to stop treating your model bill as one number and start treating it as a portfolio of task types, each with a cheapest tier that can hold its quality bar. The method below does that in five moves, using Anthropic's Claude 5.5 family as the worked example because it is the current lineup where each tier's job description, price and speed are spelled out most completely: Opus 5.5 (September 22), Sonnet 5.5 (September 28) and Haiku 5.5 (October 7). The same logic transfers to any vendor's tiered lineup; the prices and percentages here are Anthropic's, reported on its launch pages and not independently measured.

Source: Introducing Claude Opus 5.5; Introducing Claude Sonnet 5.5; Introducing Claude Haiku 5.5

1. Inventory your recurring task types and tag each with two properties: how much sustained judgment it needs, and how often it runs.
2. Route each type to the cheapest tier whose stated positioning covers it.
3. Set the effort level deliberately instead of leaving it at whatever default your surface applies.
4. In agent pipelines, let the expensive model plan and decide, and hand narrow execution to the cheap one.
5. Spot-check cheap-tier outputs against source material, and log which tier produced which subtask.

Which tier takes which work

Anthropic positions the three tiers as complements rather than substitutes, and the price gap between them is wide enough that the routing decision dominates the bill. Opus 5.5 is built for complex work requiring careful judgment: codebase-wide migrations and audits, long agentic sessions, knowledge work where one wrong assumption undermines the result. It costs $4 per million input tokens and $20 per million output, with cache reads at $0.20; at default settings, Anthropic's tests put it 40% cheaper to run than Opus 5 on typical workloads, with output generated more than 30% faster.

Source: Introducing Claude Opus 5.5

Sonnet 5.5 is strongest at well-scoped everyday tasks: fixing bugs, producing polished documents, slides and spreadsheets, routine reviews. Its sticker price is unchanged from Sonnet 5 — $2 per million input, $10 per million output — but Anthropic reports it typically needs far fewer tokens for the same work, costing up to 30% less per task and generating output 30% or more faster. Cache reads fell to $0.10 per million on October 7, which Anthropic says puts most agentic work roughly 20% cheaper, because cached context makes up a large share of those calls.

Source: Introducing Claude Sonnet 5.5; Introducing Claude Haiku 5.5

Haiku 5.5 is the high-volume tier: summaries, compaction, database queries, classification, and subagent work inside a bigger model's pipeline. For prompts up to 100,000 tokens it costs $0.10 per million input and $0.50 per million output, with cache reads at $0.01; longer prompts step up to $0.50 and $2.50. Against Haiku 4.5, Anthropic reports an average saving of around 75%, a figure that rests on a 90% price cut under the 100,000-token mark — which covered about 90% of previous Haiku traffic — a 50% cut above it, and an updated tokenizer that uses slightly more tokens per task. It is also the family's fastest model at standard speed, which is why Anthropic points it at latency-sensitive work like live customer support.

Source: Introducing Claude Haiku 5.5

Put together, the spread is the argument: on short prompts, input tokens run forty times cheaper at the bottom of the family than the top, and cache reads twenty times cheaper. Moving a narrow, frequent task down a tier is worth more than any optimization you can squeeze out of a single model.

The second dial: effort

Each 5.5 model carries an adjustable effort setting, and Haiku 5.5 is the first small model in the line to get one. Anthropic is straightforward about the trade: as effort goes up, the model works longer, so cost per task rises and score generally rises with it. The catch for a cost-minded reader is that the default differs by surface — Medium in Claude Code and the Claude apps, High on the Claude Platform — so the same task can quietly change price depending on where you run it. The savings on this dial are not marginal: on several benchmarks, Anthropic reports Sonnet 5.5 at Low or Medium effort beating Sonnet 5's best score at about a tenth of the cost per task. In practice, that means starting routine work at the lowest effort that clears your quality bar, reserving High and Max for tasks where the extra reasoning is the point, and checking which default your surface applies before you read a bill.

Source: Introducing Claude Sonnet 5.5; Introducing Claude Haiku 5.5

A working pattern: lead and sidekick

For agent pipelines, Anthropic describes Haiku 5.5 as pairing with Opus 5.5 and Sonnet 5.5 as a subagent on coding work, and a production instance of the pattern was published with the launch. Cognition's Devin Fusion runs Opus 5.5 as the lead and Haiku 5.5 as the sidekick; in a testimonial on Anthropic's page, Cognition co-founder Walden Yan reported that Fusion holds a top-tier FrontierCode score of 66.2 while cutting cost and latency. That is a vendor-published figure, not an independent measurement, but the shape of the setup is the reusable part: the expensive model spends its tokens on planning, architecture and the judgments that are hard to redo, while the cheap model handles narrow fetches — pulling a specific figure from a document, classifying an item, summarizing a chunk — where a mistake is recoverable because the lead sees the result. Rogo's applied-AI engineer described the same division of labor: while a bigger model builds a slide deck, a Haiku 5.5 subagent goes into the 10-K and pulls the segment-revenue line the deck needs.

Source: Introducing Claude Haiku 5.5

Re-verifying the cheap tier

Routing saves money only if the cheap tier's output actually holds. The rule is to make verification effort a function of stakes and proximity to the tier's ceiling: the closer a task sits to the edge of what that tier reliably does, and the more downstream damage a wrong number causes, the more of its output you check against the source material. Concretely, name the fields that must be exact — figures, names, citations — sample-check them against the originals, and keep a log of which tier produced which subtask, so that when something is wrong you can trace it to a layer and move that task class up a tier or raise its effort, rather than re-auditing everything.

The discipline has a published precedent in SentX's model card for its own assistant, Victoria, which carries selective, human-like memory. SentX lists as a known limit that answers can contain incorrect facts, citations or calculations, and directs users to open the cited sources and check the supporting passage, to repeat details that must remain exact, and to keep a portable checkpoint of checked findings and open questions for work that spans sessions. Read through as routing practice, the checkpoint does double duty: it records what has been verified, and it records which tier did the work, so your audit effort lands on the layers that actually carry risk instead of being spread evenly across the bill.

Source: Victoria AI Model Card

Keeping the numbers honest

Two caveats keep this method from overstating itself. First, every percentage here is vendor-reported — Anthropic's tests on its own workloads, or customer statements published alongside the launches — and Anthropic itself notes that at these capability levels, benchmark margins are a less reliable guide to real-world differences. Second, the prices are a snapshot of October 2026, and they move: Sonnet 5.5's cache-read price was halved nine days after launch, which quietly changed the economics of any routing decision made in between. Before you commit a budget, re-pull the current price list and run the arithmetic on your own volume, because the right split for your workload is something only your task inventory will confirm. The map above tells you where to look; your numbers tell you where to land.

Source: Introducing Claude Opus 5.5