Model tier (size and price ladder)

What is a model tier?

A model tier is one rung on the ladder of sizes and prices that every model generation ships in. Anthropic sells Haiku, Sonnet, Opus and Fable. OpenAI sells its GPT-5.6 line as Luna, Terra and Sol, with GPT-6 Astra above them, after years of nano, mini and the full model. Google sells Gemini as Flash-Lite, Flash and Pro. The names differ, the idea is the same: one generation, offered at three or four points on a scale from small and cheap to large and expensive.

The tiers are meant to be used together. The vendors themselves describe the small tier as the one for high-volume, straightforward work and the large tier as the one for the hardest reasoning, and they expect you to send each request to the rung that fits it. Think of a delivery fleet rather than one truck: you do not send the largest lorry out for every parcel.

What changes from one tier to the next

Capability on hard tasks. The gap shows up on work that needs several steps of judgement: reading a contract for a clause that is missing, finding a bug across a large codebase, planning a long agent run. On a task with one obvious right answer, extracting an invoice total or sorting a ticket into one of five queues, the small tier and the large tier usually give the same answer. You pay for the difference on the hard cases, and in most workloads the hard cases are a minority.

Speed and price. A smaller model needs less compute per token, so it answers faster and costs less. Anthropic's model table ranks its tiers from fastest to slowest in exactly the order of their price.

Context window and output limit. Not always the same across the ladder. Claude Haiku 4.5 takes 200,000 tokens of context and writes up to 64,000, where the three tiers above it take a million and write up to 128,000. Google's Gemini 3.5 Flash-Lite, by contrast, takes the same million-token context as its bigger siblings.

Features. Some knobs only exist higher up. Anthropic's effort parameter, which trades thinking time for cost inside one model, is not supported on Haiku 4.5. If your task needs a 500-page document in one prompt, the price comparison is moot on a tier that cannot read it, so check the feature table before you compare prices.

The price gap as of September 2026

Prices per million tokens, input first and output second, from the vendors' own pricing pages on 3 September 2026. Rounded, in US dollars.

• Anthropic. Claude Haiku 4.5 at 1 and 5, Sonnet 5 at 2 and 10, Opus 5 at 5 and 25, Fable 5.1 at 10 and 50. Bottom to top is a factor of ten on both input and output.

• OpenAI. GPT-5.6 Luna at 0.20 and 1.20, Terra at 2 and 12, Sol at 4 and 20, GPT-6 Astra at 10 and 50. Bottom to top is roughly a factor of fifty on input and forty on output.

• Google. Gemini 3.5 Flash-Lite at 0.30 and 2.50, Gemini 3.8 Flash at 0.75 and 3.75, Gemini 3.1 Pro (still in preview) at 2 and 12 for prompts up to 200,000 tokens. Bottom to top is roughly a factor of seven on input and five on output. Google has announced that most Gemini 3 prices go up on 1 January 2027.

So the spread between the cheapest and the dearest rung of one generation sits somewhere between five and fifty times, depending on the vendor. Batch processing and prompt caching lower the numbers, but the ratio between the tiers stays. The absolute numbers age fast (Anthropic's launch price for Sonnet 5 was due to rise on 1 September 2026 and did not), so treat the ratio as the durable fact and look up the numbers on the day you build the business case.

Pick the tier per task, not per company

The mistake we see most often is a company-wide decision: "we use model X". A model tier is a per-request choice, and the request that needs Fable is rarely the one that runs ten thousand times a day.

Split your workload into the tasks it actually contains. Send the high-volume tasks with one right answer to the small tier: classification, extraction, routing, reformatting. Send the tasks that need judgement to a large tier: a contract review, a root-cause analysis, an agent that has to plan twenty steps. Then run your own eval on each task, with your own documents, and move a task up or down a rung when the numbers say so. Anthropic's guide to choosing a model and OpenAI's model selection guide come down to the same instruction: build a test set for your own use case, swap in the smaller model, and check whether accuracy holds at the lower price.

A worked example. A company receives 20,000 customer mails a month and wants each one sorted into one of eight queues. Say each call sends about 1,500 input tokens (the mail plus the instructions) and gets back 20 output tokens (the name of the queue).

• Small tier (Claude Haiku 4.5, 1 and 5 dollars): 30 million input tokens cost 30 dollars, 400,000 output tokens cost 2 dollars. About 32 dollars a month.

• Largest tier (Claude Fable 5.1, 10 and 50 dollars): 300 dollars plus 20 dollars. About 320 dollars a month.

Ten times the price for a task where both tiers will agree on almost every mail. The saving is modest here, but the same arithmetic on an agent that makes thousands of tool calls a day decides whether a feature pays for itself.

Small tier versus large tier: cost per task against error rate

Price per token is the wrong unit for the decision. The unit that matters is cost per correct result, and that depends on two things the pricing page does not show: how often each tier gets your task wrong, and what a wrong answer costs you.

Take the mail example again and suppose the small tier misroutes 3 percent of mails and the large tier 1 percent. That is 400 extra mails a month in the wrong queue. If a misrouted mail costs a colleague five minutes to spot and forward, the small tier costs you about 33 hours of someone's time a month, against 288 dollars of extra model spend for the large tier. Now the large tier is the cheaper option. The two percentages are assumptions to show the arithmetic; the real ones come out of your eval, and they decide the answer.

Anthropic published its own measurement of the same trade in 2026. On an easy slice of a web research benchmark, a Fable 5 coordinator handing work to a Sonnet 5 worker cost about half as much as Fable 5 alone, with 15 to 18 correct answers out of 20 either way. On the full, harder set the economics reversed: Fable 5 alone reached the same accuracy at 22 to 30 percent lower cost. Same models, same ladder, opposite answer, decided by how hard the task was.

Tiers, model routing and versioning

Routing is what turns tiers into a saving. Model routing is deciding at runtime which model handles a request. The simplest form is static: this endpoint always calls the small tier, that one the large tier. The next step is a rule: a short mail goes to the small tier, a mail with a ten-page attachment goes up a rung. The most involved form puts a classifier or an LLM gateway in front that scores difficulty and picks the rung.

Tiers move every generation. A new generation usually lifts the whole ladder: Anthropic describes Haiku 4.5 as near-frontier intelligence at its lowest price, and Google calls its Flash-Lite frontier-class. So a routing decision from twelve months ago is stale: the task you sent to the large tier may now fit the mid tier.

Pin the version, not the tier name. "Haiku" or "Flash" is a marketing name that gets reused every generation; the model ID is what your code calls. Since the Claude 4.6 generation every Claude model ID is a fixed snapshot: claude-sonnet-5 never silently changes weights, and an updated model ships under a new ID. Google's Gemini docs say most production apps should use a specific stable model rather than a -latest alias, which hot-swaps to each new release with two weeks' notice. Pinning also makes retirement your problem: Anthropic gives at least 60 days' notice before it retires a model, OpenAI at least six months for generally available models, and the GPT-5 snapshots from 2025 stop working on 11 December 2026. Put the model ID in configuration, one place per task, and rerun the eval when you move it.

What to watch out for with model tiers

Defaulting to the largest. Picking the top tier for everything feels safe, and it is the most expensive way to be safe. Anthropic's own docs say many applications should start with Haiku and only upgrade for a specific capability gap. If nobody has measured whether the large tier is actually more accurate on your task, you are paying a factor of ten for a feeling.

Defaulting to the cheapest. The opposite mistake is cheaper on the invoice and dearer everywhere else. A small tier that fails on the hard 5 percent produces rework, retries and a colleague who stops trusting the output. Retries are a hidden multiplier: an agent that fails on the small tier and tries three more times has paid four times for one result, which on Anthropic's ladder is already more than a single clean run on Sonnet.

The ratio is stable, the prices are not. Rebuild the business case at each new generation, and check for announced increases, like the rise Google has planned for 1 January 2027, before you commit to a volume.