When a premium model is worth it (and when it's just expensive)
The question of when to use a premium LLM is usually asked backwards. Teams ask "is the expensive model better?" — it usually is, somewhat — when the question that decides the money is "what does it cost me when the cheap model is wrong?" Price the failure, not the call. Once you do, the premium tier stops being a status decision and becomes an arithmetic one.
Here's the arithmetic in its simplest form. A premium model at 10× the price is worth it exactly when it prevents failures worth more than 10× the price difference, at the rate it actually prevents them. Both halves of that sentence do work. The failure has to be expensive, and the premium model has to actually fail less on your traffic — which is a measurement, not a brochure claim. I covered the measurement half in evaluating models on your own traffic; this post is about the first half, because it's the one teams skip.
Price the failure, not the call
Every model call has two prices. The one on the pricing page, and the one you pay when the output is wrong. The first is fixed and visible. The second varies by four or five orders of magnitude across the calls in a single agent loop, and it's invisible until you go looking.
A relevance-filtering call that misjudges a search result costs you one slightly worse input to the next step. Call it fractions of a cent of downstream waste. A call that drafts the summary your user actually reads costs you trust when it's wrong — hard to price, but real, and much larger. A call that triggers a refund, sends the email, or commits the change costs you the cleanup, the apology, and sometimes the customer.
The rack-rate gap between model tiers is maybe 10–30×. The failure-cost gap between those three calls is enormously wider. Which means the model tier should track the failure cost, not the other way around. Paying premium rates on the filtering call buys you almost nothing. Paying budget rates on the irreversible call saves you almost nothing and risks a lot.
Where the premium tier earns its keep
Three categories cover most of the calls where I think the top tier is defensible. They share one property: the cost of being wrong dwarfs the cost of the call.
Irreversible actions. Anything the agent does that can't be cheaply undone — writes to production systems, messages sent to humans, purchases, deletions. When the blast radius of a bad decision is measured in support tickets or money, the delta between model tiers is the cheapest insurance you can buy. Note the corollary: if you can make the action reversible — draft instead of send, propose instead of commit — you can often downgrade the model. Reversibility is a substitute for intelligence, and it's usually cheaper.
User-visible output. The paragraph your user reads is your product's face. A stilted summary or a subtly wrong claim in visible text costs trust at a rate no invoice captures. Internal plumbing can be mediocre; the last hop to the user's eyes generally shouldn't be.
Legal, financial, and medical text. Anywhere a wrong sentence has professional consequences — contract summaries, financial figures, compliance language — the failure cost has a lawyer's hourly rate somewhere in it. These calls are usually a sliver of volume. Route them up without agonizing.
Look at what's not on the list: "hard-seeming" tasks. Difficulty is an argument for escalation only when the cheap model demonstrably fails, which is an eval result, not an intuition.
Where it's just expensive
The mirror image: high-volume, low-stakes calls, which in most agent loops are the majority. Query rewriting. Classification. Deduplication. Extraction into a schema. Deciding whether a search result is worth reading. Each of these is checked or absorbed by a later step, so an individual mistake costs nearly nothing — the loop is self-correcting at exactly the points where volume is highest.
Running these on a premium model is how a bill triples with no measurable quality change. The plumbing calls fail cheap and run constantly; the tier that handles them should be the cheapest one that passes your evals, which is the whole argument of small models first. If you can't say what a wrong answer to a given call would cost you, that's your tell — it probably costs nothing, and the call belongs on the budget tier until an eval says otherwise.
Escalation criteria you can write down
"Use judgment" doesn't survive contact with a team. Write the criteria into the routing layer. Mine reduce to a short list — a call escalates to the premium tier when any of these is true:
| Criterion | Test |
|---|---|
| Irreversible | No cheap undo exists for the action taken |
| User-visible | The output ships to a human's eyes unedited |
| Regulated | Legal, financial, or medical consequences attach |
| Demonstrated failure | The cheaper tier failed this task class in evals |
| Confidence floor | The cheap model itself flags low confidence or the parse fails |
Everything else defaults down. The last two rows matter most, because they make the system adaptive: escalation stops being a static label on a call site and becomes a response to evidence. A cheap call that fails validation gets one escalation — a retry on the premium model — and that retry spends from the task's budget like any other call. The rest of the latency-quality-cost triangle applies here unchanged; premium tiers are typically slower as well as pricier, so escalation costs you twice.
The same ladder, one shelf up
If this structure looks familiar, it's because it's the search-provider ladder wearing a different hat. The identical web search costs $0 on Wikipedia and $0.005 on You.com — a paid rung is worth it only for the queries the free rungs can't answer, which is why Frugal walks the ladder cheapest-first and lets the paid providers earn their place per call. Premium models are the same shape: a pricier rung that must justify itself against the specific failure it prevents, not against a general sense that better is better.
The failure mode is also the same. Defaulting to the top rung "to be safe" is the model-selection version of sending every search to the most expensive provider — you pay rack rate for peace of mind on ten thousand calls to protect the hundred that needed it. Buy the insurance where the risk is. Everywhere else, the cheap rung plus a good escape hatch beats the expensive rung with nothing to prove.
Start with an inventory: list your call sites, and for each one write down what a wrong answer costs. Most teams find the list splits cleanly — a long tail of plumbing where failure is free, and a handful of calls where it very much isn't. Route accordingly, eval the boundary, and revisit when models or prices move. There's more on making these decisions systematically in the model selection series.