How to Choose an LLM (2026): Cost, Context, Speed, Quality

You open three leaderboards, and each crowns a different model. A launch post says the new release "wins 11 of 14 benchmarks". Meanwhile you just need one API for a support bot or a coding agent. And no surprise invoice next month.

Here's how to choose an LLM without guessing. Decide what a wrong answer costs you and shortlist two or three models from that tier. Then compare them on cost per completed task, using your own prompts. Leaderboards build the shortlist. They can't make the pick.

Most guides skip the fine print. Four rules on the official price sheets can reverse a cheap-versus-expensive ranking. One of them nearly doubles a bill when the prompt grows by 6%.

Written from the pricing pages and model docs of Anthropic, OpenAI, Google and Z.ai, checked on 31 October 2026. Every cost below is our own arithmetic on list prices in US dollars; we didn't run our own benchmark.

Start with one question: what does a wrong answer cost you?

Every vendor now sells a ladder of models: a frontier model, one or two workhorses and a small, fast one. The gap between rungs barely shows on easy work and shows a lot on hard work.

So the first question isn't "which model is best". It's how bad a wrong answer is.

Sort your task into one of three buckets:

• Cheap to be wrong, easy to check: tagging tickets, pulling fields out of invoices, routing, short summaries. Start with the small model.
• Costly to be wrong, but you review the output: drafting, everyday code, data analysis, support replies a person approves. Start with a workhorse.
• Costly to be wrong and nobody checks every line: agents that change production code, long research reports, anything that runs for hours. Start with a workhorse at higher effort, and test the frontier model against it.

The vendors' own advice splits the same way. Anthropic's model guide describes an "efficiency-first" route starting on Claude Haiku 5.5 and a "capability-first" route starting on Claude Opus 5.5. Its overview page says to "start with Claude Opus 5.5 for most workloads".

OpenAI's model selection page says you "can default to Astra" if cost and latency aren't a concern. Then it tells you to keep "the lightest setting that meets your quality bar".

Here's how the current lineups map onto those buckets. The grouping is ours, based on each vendor's own description of the model.

Prices are input / output per million tokens at standard rates. A million tokens is roughly 750,000 English words, or about ten novels.

For head-to-head detail, our GPT-6 Astra vs Claude Fable 5.1 comparison and our Gemini 3.8 Flash vs GLM-5.3 vs Opus 5 comparison go model by model. Both were written before Opus 5.5 replaced Opus 5 as Anthropic's default recommendation.

Look at that table for a moment and the obvious move is to sort by price. That's the first mistake.

Why price per token is the wrong number

You don't pay for tokens. You pay for finished work. A model at half the token price that fails a third of your tasks still bills you for the failures. Then for the retries, and for whoever fixes the output.

Anthropic published a clean example in its cost and intelligence guide. It priced runs on a subset of the SWE-bench Pro coding benchmark the way a customer is billed. Claude Opus 5.5 at its default effort solved 92.8% of tasks for $0.22 per solved task. Claude Fable 5.1, the more capable and pricier model, solved 92.3% (a single run) for $1.19.

Same score, about five times the cost. And the cheaper Sonnet 5.5 finished about five points behind Opus at half the price per solved task.

You're probably thinking that's a vendor grading its own homework. It is, and Anthropic calls the results "directional, not guarantees". But the useful part isn't who won.

It's that ranking by cost per solved task looks nothing like ranking by price per token. You only see that by measuring.

The formula is short. Cost per completed task = cost per attempt ÷ success rate, plus the time you spend fixing what failed.

Say you run 1,000 tasks a month (a hypothetical). Model A costs $0.01 an attempt and passes 70%. Model B costs $0.02 and passes 95%. On tokens alone, A wins: about $0.014 per success against $0.021.

But A leaves 300 failures and B leaves 50. If each failure takes five minutes to spot and fix, that's 25 hours of your month against about 4.

So cost per task is the yardstick. But to estimate cost per attempt at all, you need to read the price sheet more carefully than most people do.

Four pricing rules that flip the ranking

None of these are hidden. They're all on the official pages. They just don't show up in the headline price, and each one can turn the "cheap" model into the expensive one.

1. Long-context cliffs reprice the whole request

OpenAI's current models have a 1,050,000-token context window, but the price changes at 272,000 input tokens. The GPT-6.1 Sol model page says prompts over that line "are priced at 2x input and cache rates and 1.5x output for the full request". Not the tokens above the line. All of them.

Here's what that does to one agent turn on GPT-6 Astra, with a warm cache, 5,000 new input tokens and 2,000 output tokens. At 260,000 cached tokens the turn costs $0.41. Add 15,000 more tokens of context, about 6%, and it costs $0.80.

Claude Haiku 5.5 has the same kind of cliff at a lower line. Prompts over 100,000 tokens pay $0.50 input and $2.50 output instead of $0.10 and $0.50.

A 99,000-token prompt with 1,500 output tokens costs us $0.0021 by our math; a 103,000-token one costs $0.0107. That's five times the price for 4% more prompt. Anthropic notes the higher rate applies "even when part of its prompt is a cache hit".

Claude's other current models, Gemini 3.8 Flash, Gemini 4 Argon and GLM-5.3 list no long-context surcharge on the pages we checked. If your prompts grow as an agent works, that alone can decide it.

2. Cache-read rates matter more than input rates for agents

Agents resend the whole conversation on every turn: system prompt, tool definitions, every earlier step. With prompt caching, the repeated part bills at a cache-read rate instead of the full input rate. Anthropic reports that agent loops on its platform read a median 84% of their input from cache.

So for an agent, the cache-read price is often the biggest line on the bill. And it varies far more than the headline rates:

Fable 5.1's cache reads cost 2.5% of its input price. Opus 5.5, Sonnet 5.5 and GPT-6.1 Sol charge 5%; GPT-6 Astra and GPT-6 Luna, 10%. GLM-5.3 charges $0.26 against a $1.40 input price, about 19%.

That last one flips a ranking. GLM-5.3's input and output prices are both lower than Claude Sonnet 5.5's.

On a short, chat-shaped request (2,000 cached tokens, 1,000 new, 400 out) GLM-5.3 costs $0.0037 and Sonnet 5.5 costs $0.0062, so GLM wins. On an agent turn with 260,000 cached tokens, 5,000 new and 2,000 out, GLM-5.3 costs $0.083 and Sonnet 5.5 costs $0.056. Same models, opposite answer, because of one column.

3. Promotional prices expire on a date

Google's two newest models are on launch pricing with end dates printed on the page. Gemini 4 Argon costs $2 input and $10 output "through November 30, 2026", then $4 and $20 from 1 December. Gemini 3.8 Flash costs $0.75 and $3.75 through 31 December, then $1.50 and $7.50 from 1 January 2027.

Both double. That's fine if you budget for it. In November, Argon's price matches GPT-6.1 Sol and Sonnet 5.5. From December it matches Opus 5.5.

Price your shortlist at the rate you'll pay in three months, not today's.

4. A token isn't the same size everywhere

Every vendor counts tokens with its own tokenizer, so "per million tokens" isn't a shared unit. Anthropic's pricing page says its newer tokenizer, used from Claude 4.7 on, "produces approximately 30% more tokens for the same text" than the old one. The same document can be 100,000 tokens on one API and noticeably more on another.

The fix is boring. Before you compare prices, run a sample of real prompts through each vendor's token counter, or read the usage numbers from a test call.

Once the pricing is honest, the next filter is physical: how much text the model can take in and send back.

How much context do you actually need?

Less than the spec sheets suggest. Almost every model in the table above now advertises about a million tokens of context, so the window rarely decides it any more. Three limits are more useful to check:

• Maximum input, not window size. OpenAI's GPT-6.1 Sol has a 1,050,000-token window but a "Maximum input tokens: 922,000" line on its model page.
• Maximum output. Claude's current models, OpenAI's and GLM-5.3 list 128,000 output tokens. Gemini 3.8 Flash lists 65,536, which matters if you generate long documents or big code files in one pass.
• Input type. GLM-5.3 "currently supports text-only inputs", so screenshots, scanned PDFs and charts need another model.

And a huge context window isn't free even without a cliff: every token you stuff in is billed on every call. For a large document set that changes often, retrieval is usually cheaper than pasting everything in. Our guide to building a RAG chatbot from your website walks through that route.

When speed decides it

Speed has two parts: how long until the first word appears, and how fast the rest streams. A chat product someone watches needs both. An overnight batch job needs neither.

Anthropic's model overview rates comparative latency from "Slower" (Fable 5.1) through "Moderate" (Opus 5.5) and "Fast" (Sonnet 5.5) to "Fastest" (Haiku 5.5). It doesn't publish tokens per second, and we didn't measure them.

Two paid levers change speed without changing models:

• Fast modes cost more. OpenAI prices Fast at 2x Standard and Ultrafast at 6x on GPT-6.1 Sol. Anthropic's fast mode for Opus 5.5 is $8 input and $40 output, double the standard rate, for "up to 2.5x higher output speed".
• Batch processing costs less. Anthropic, OpenAI and Google all list batch discounts of 50% for work that can wait (Anthropic's window is up to 24 hours).

If nobody is waiting for the answer, batch is the easiest saving on this page. Half price, same model.

Privacy, data location and open weights

Sometimes the pick is made by a rule, not a benchmark. Three to check before you shortlist anything:

Free tiers can train on your data. Google's pricing table lists "Used to improve our products: Yes" for Gemini 3.8 Flash on the free tier and "No" on the paid tier. Don't prototype with customer data on a free key.

Keeping data in a region costs extra. OpenAI charges a 10% uplift for regional processing on models released on or after 5 March 2026. Anthropic applies a 1.1x multiplier when you request US-only inference.

Open weights give you control, not convenience. Z.ai publishes GLM-5.3's weights on Hugging Face under a permissive licence. Its one extra rule: model-as-a-service businesses with over $10 billion in yearly revenue must pass a Z.ai security review.

But the repository holds 141 weight files for a mixture-of-experts model with 256 routed experts. That's data-centre hardware, not a laptop. For most teams the real benefit is that you could move to another host later.

You can try GLM-5.3 through the Z.ai API. One catch from Z.ai's docs: if you've ever subscribed to a GLM Coding Plan, you can currently reach the model API only through the OpenAI-compatible Chat Completions protocol.

How to run your own model bake-off in an afternoon

This is the step that settles it, and it's smaller than it sounds. OpenAI's guide says to "experiment using the same inputs"; Anthropic's says a good evaluation set "is the most important step in the process". Here's a version one person can do:

1. Collect 20 to 50 real inputs from your workload. Include the hardest tenth on purpose: in one Anthropic run, two of 20 problems carried 43% of the spend.
2. Write the pass rule before you look at outputs. "Contains the invoice total and date", "tests pass", "a reviewer would send it unedited".
3. Pick two or three candidates: the workhorse you expect to use, the model one rung down, and one from another vendor.
4. Run each at its default effort, then once at a lower effort. Effort settings often move cost more than a model swap does.
5. Log input, cached and output tokens from each response, plus pass or fail, plus minutes spent fixing.
6. Divide cost by passes. Add your fixing time. Pick the cheapest model that clears the bar.

For step 6 we wrote a small calculator that applies the long-context and cache rules above to any token counts. Give it cached, new and output tokens, plus a request count:

$ python3 llm_cost.py 2000 1000 400 100000
cached=2,000 fresh=1,000 out=400 x100,000
Claude Fable 5.1                 $0.03050/request  $3,050.00 total
Claude Opus 5.5                  $0.01240/request  $1,240.00 total
Claude Sonnet 5.5                $0.00620/request  $620.00 total
Claude Haiku 5.5                 $0.00032/request  $32.00 total
GPT-6 Astra                      $0.03200/request  $3,200.00 total
GPT-6.1 Sol                      $0.00620/request  $620.00 total
GPT-6 Luna                       $0.00032/request  $32.00 total
Gemini 3.8 Flash (to 31 Dec)     $0.00240/request  $240.00 total
Gemini 3.8 Flash (from 1 Jan)    $0.00480/request  $480.00 total
GLM-5.3                          $0.00368/request  $368.00 total

That's an excerpt of one real run. For 100,000 short requests a month, Haiku 5.5 costs $32 and Fable 5.1 costs $3,050, about 95 times more.

That's why the bake-off matters. If Haiku 5.5 or Luna passes your test set, the frontier model is a $3,000 habit.

And if the small model passes most tasks but stalls on a few, you don't have to choose just one. Anthropic's guide describes pairing a low-cost model with a frontier "advisor" it consults only on hard decisions.

A simpler version needs no second model. In Anthropic's tests, running at low effort and re-running only the failures at high effort cost about 40% less than high effort throughout, at the same pass rate. If you build either setup, our MCP explainer covers how agents connect to the tools they'll call.

Which LLM should you start with?

High-volume work that's easy to check, like tagging, extraction and routing? Start with Claude Haiku 5.5 or GPT-6 Luna, and keep prompts under Haiku's 100,000-token line. Move up only for the tasks that fail.

Building a product people use every day? Start with a workhorse: Claude Sonnet 5.5 or GPT-6.1 Sol at $2 / $10. Add Gemini 3.8 Flash if you've budgeted for its January price. Run all three on your test set; at that price level, pass rate decides it.

If you run long agent sessions with big, stable context, compare on cache-read price and long-context rules first. Claude's 1M-token window at flat pricing and low cache reads favour Opus 5.5 and Fable 5.1 there. Our Claude Fable 5.1 vs Opus 5 breakdown shows how cache-heavy turns change that pair's maths.

If being wrong is expensive and nobody checks every line, test the frontier models against Opus 5.5 at high effort: Fable 5.1, GPT-6 Astra, and Gemini 4 Argon at its December price. Pay frontier rates only if your own pass rate says they earn it.

Need open weights, or a lower-priced vendor outside the US for text-only work? Test GLM-5.3, as long as cached context isn't most of your bill.