Choosing a model for a use case: a practical checklist.
Published list prices across one vendor's own catalogue span roughly a hundred to one as of October 2026 — about $0.10 per million input tokens at the small end against about $10 at the top, and $0.50 against $50 on output — which means the model you pick moves your bill by two orders of magnitude while moving quality by a few points on tasks that are mostly easy. That is the whole decision, and it expires: the right answer changes every quarter or two, so the checklist's real output is not a model. It is a swap cost low enough that next quarter's decision is cheap.
Step 1Start from the task, never from the model — because the constraints eliminate more candidates than quality ever will.
The most common failure is picking a model first ("we'll use the best one") and retrofitting the use case to it. Invert it. Before naming any model, write down: what goes in and out (modalities), how hard the core task actually is, the latency users will tolerate, the per-request cost ceiling at expected volume, and where the data is allowed to go. These eliminate most of the candidate space before quality enters.
Two of those five do more work than the rest in 2026, and both are easy to underweight because they are not what leaderboards measure:
- Cost is a hard constraint, not a preference. The spread inside a single vendor's catalogue is roughly 100× on input and output alike; the spread across vendors is wider still, with aggregator trackers putting a median flagship around $6 per million blended tokens in October 2026 and frontier prices roughly 84% below their 2023 level. At low volume none of this matters. At agentic volume — where a single task is twenty model calls, each replaying a long prefix — the tier decision is the product decision.
- Data boundary is binary. If inference data may not leave a jurisdiction or a VPC, every hosted frontier API is eliminated in one line and you are choosing among open-weight checkpoints. No amount of quality argues with it. See data residency and open vs closed models.
There is also a pricing cliff that catches context-hungry designs. At least one major provider lists a step at the 200K-token mark — Gemini 3.1 Pro at roughly $2 in / $12 out per million below it and roughly $4 / $18 above, as listed in October 2026. A design that stuffs 300K tokens into the window therefore pays twice: more tokens, each priced higher. Retrieving the right 20K is not merely a quality choice.
Step 2The checklist, in order.
Steps 1–5 are hard constraints — they remove options. Step 6 is the only place public benchmarks belong, and the reason is visible in the current numbers rather than theoretical. On the open-weight coding leaderboards in late 2026, one tracker put MiniMax M3 top on SWE-bench Pro at 59.0% while another listed GLM-5.2 at 62.1% on the same benchmark; on SWE-bench Verified the vendor-reported leaders sit within a tenth of a point of each other. Most of those figures are self-reported on different harnesses. They are a filter for narrowing five candidates to three, and they are not evidence about your task — which is the argument reading benchmarks makes in full.
Steps 7–8 are where the decision is actually made, on your own data. Score the three axes together: a model that wins on quality and loses on cost has not won. And score with enough samples to know a real gap from noise — two points apart on fifty examples is not a result, per eval variance and statistical power.
Step 3Default to the smallest thing that works, then escalate — and here is what that is worth.
The mature posture is the opposite of "start at the frontier and cut costs later". Start from the cheapest tier that plausibly fits, prove it passes your eval, and move up only where it measurably fails. Most real workloads are dominated by easy requests; sizing for the rare hard ones means overpaying on every easy one.
Work a concrete case. A support-triage agent: 2 million requests a month, roughly 3,000 input tokens each (ticket plus policy context) and 400 output tokens. That is 6 billion input and 800 million output tokens monthly. Against October 2026 list prices:
- Small tier (~$0.10 / $0.50 per million): $600 + $400 = ~$1,000 / month.
- Mid tier (~$5 / $25): $30,000 + $20,000 = ~$50,000 / month.
- Top tier (~$10 / $50): $60,000 + $40,000 = ~$100,000 / month.
Now the escalation path. Suppose the small model passes your eval on 85% of tickets and you route the remaining 15% up to the mid tier: 0.85 × $1,000 + 0.15 × $50,000 ≈ $8,350 / month, roughly six times cheaper than running the mid tier on everything, for quality that matches it on the hard cases by construction. That arithmetic — not a benchmark delta — is why routing is the highest-leverage architectural choice in the stack.
Three refinements, in order of payoff:
- Cache before you downsize. If 2,500 of those 3,000 input tokens are a stable policy prefix, prompt caching cuts the input line by more than a tier change does, and it costs no quality at all. Do the free thing first.
- Size per step, not per system. Inside an agent loop the steps differ in difficulty: a cheap model to route and extract, a reasoning model only for the genuinely hard step, a mid model to synthesise. One model for the whole loop overpays on most of it.
- Move the high-volume narrow jobs off the API entirely. Embedding, reranking and classification are where small and local models are not merely adequate but competitive, and they are usually the highest-call-count components you have.
The escalation path has to be cheap to be real. If "escalate" means a different prompt, a different output schema and a different parser, nobody will build it and the workload will quietly settle on the expensive model. Make the tiers interchangeable at the call site — same contract, different model string — and escalation becomes a config line instead of a project.
Step 4Design for a decision that expires in about a quarter.
Every specific recommendation on this page is perishable; the procedure is not. Prices fall, the open/closed gap oscillates, today's frontier becomes next year's cheap tier, and vendors deprecate the exact model string you hard-coded. So the question to design against is not "which model" but "what does it cost me to change my mind in four months". Four things decide that, and only the first is the one teams worry about:
- The API is the easy part. Any gateway or thin adapter makes the call site model-agnostic in an afternoon. If this is where your migration effort goes, you have the cheap problem.
- The prompt is the expensive part. Prompts are tuned to a model's quirks and do not transfer intact — see prompt portability. Budget a re-tune, not a copy, and keep prompts in version control next to the eval that justifies them.
- The embedding index is the irreversible part. Swapping an embedding model invalidates every vector you have stored; the cost is a full reindex, not a config change. Decide the embedding model on a slower clock than the generation model, deliberately.
- Without an eval set you cannot change anything safely. This is the real lock-in. A team with fifty graded examples re-runs them in an hour and switches on evidence; a team without them has no way to tell an upgrade from a regression and therefore never moves. The eval set is the prerequisite for every other item here.
Deprecation makes this concrete rather than hypothetical: model strings are retired on vendor schedules, and a system that cannot re-run its eval against a replacement is a system that migrates under a deadline, by vibes. Model deprecation and migration covers the operational drill.
If you do the checklist once and nothing else, do this: run steps 1–5 honestly, pick the cheapest surviving candidate rather than the best-reviewed one, and spend the time you saved building the fifty-example eval set instead of comparing leaderboards. The cheap model fails visibly on your eval or it does not — either way you learn more in a day than a week of benchmark reading gives you, and you end up owning the one asset that makes every future model decision a one-hour job. Then set a calendar reminder for one quarter out to re-run the same eval against whatever shipped since; that recurring hour is the entire maintenance cost of a decision everyone else re-litigates from scratch. For the framing behind the trade-offs, see cost, quality and latency; for keeping the bill under control once you are live, agent cost control.