Claude, GPT, or Gemini: How to Choose an LLM in 2026

Strip away the launch-day theatrics and the model-picker question in 2026 is surprisingly structured. Anthropic, OpenAI, and Google have converged on the same product shape: a frontier tier for the hardest problems, a mid tier that carries most production work, and a small tier for high-volume plumbing. Million-token context windows are now table stakes at the top of every lineup. Raw capability still differs at the margins, but for most products the deciding factors live elsewhere: cost structure, latency, tool-calling reliability, ecosystem fit, and how painful it would be to leave.

This post gives you the current state of all three families as of August 2026 — model names, context windows, and headline prices, checked against the official pricing pages, which you should treat as the only durable source of truth — and then walks through the questions that actually decide the choice. Not “which model tops the leaderboard,” but which tier your task needs, how much context you really consume, what your input/output token mix costs, and how well each vendor’s models drive tools.

By the end you should be able to shortlist a specific model for a specific job — and, just as important, structure the decision so you can revisit it in a quarter without a rewrite.

Match the capability tier to the job, not the vendor

The first question is not “Claude or GPT or Gemini.” It is: what tier of model does this task actually need? Each family ships three broad tiers, and the tier decision moves your cost and latency by an order of magnitude; the vendor decision usually moves it by a factor of two or three.

• Frontier — hard reasoning, complex agentic coding, long-horizon multi-step work, anything where a wrong answer is expensive. Claude Fable 5 and Opus 4.8, GPT-5.6 Sol, Gemini 3.1 Pro.
• Mid — the workhorse tier where most product features should live: drafting, summarization, structured extraction with some judgment, moderate coding. Claude Sonnet 5, GPT-5.6 Terra, Gemini 3.6 Flash.
• Small — classification, routing, tagging, simple extraction, guardrail checks, anything you run millions of times. Claude Haiku 4.5, GPT-5.6 Luna, Gemini 3.5 Flash-Lite.

The most common mistake is defaulting to a flagship for everything. Frontier models cost five to fifty times more per token than the small tiers and respond noticeably slower — the small models are not just cheaper, they are faster, which matters for anything user-facing and interactive. The second most common mistake is the reverse: forcing a small model to do frontier work and then blaming the vendor. Pick the tier first; comparison shop within it second.

The three lineups as of August 2026

Here is where the families stand today. Prices are dollars per million tokens. Several of these figures have already changed this year — Terra and Luna were repriced within weeks of launch — so verify against OpenAI’s pricing page, Google’s Gemini API pricing, and Anthropic’s pricing before you put numbers in a budget.

A few footnotes that matter. Anthropic also sells Claude Opus 4.8 at $5 / $25 with the same 1M window — priced head-to-head against Sol — and Sonnet 5 carries introductory $2 / $10 pricing through August 31, 2026. Gemini 3.1 Pro is still labeled a preview, and its listed rates apply to prompts up to 200K tokens; beyond that, input doubles to $4 and output rises to $18. The GPT-5.6 family (announced in July 2026) shipped at higher prices, and Luna was cut by 80% within three weeks — a good reminder of how fast this table rots.

Context windows: capacity is not the same as cost

On paper the top tiers have converged: roughly a million tokens everywhere, with Claude Haiku 4.5 the outlier at 200K. In practice two things separate them. First, max output: Claude Fable 5 and the GPT-5.6 family can emit up to 128K tokens in one response, while Gemini 3.1 Pro and 3.6 Flash top out at 64K. If you generate long documents or large code diffs in a single shot, that limit is a real constraint before context ever is.

Second, long context has a meter on it. OpenAI bills requests beyond 272K input tokens at 2× input and 1.5× output for the whole request; Google’s over-200K pricing tier for Gemini 3.1 Pro works the same way. A “million-token window” is not a flat-rate buffet — filling it is both slow and expensive on every provider. Most products that think they need giant context actually need retrieval: a working set of tens of thousands of tokens, refreshed per request. Ask what your 95th-percentile prompt size really is before you pay for headroom you never use.

Price the traffic you will actually send

Headline prices mislead because the two directions cost wildly different amounts: across all three vendors, output tokens run roughly 5–8× the price of input tokens. That means your workload shape matters more than the sticker. Summarization and extraction are input-heavy and cheap; open-ended generation is output-heavy and expensive; agents are dominated by re-sent conversation history, which makes them ideal candidates for caching.

Caching is where the vendors genuinely differ. On the Claude API, cached prefix reads cost roughly a tenth of the base input price, with cache writes billed at 1.25× (five-minute TTL) or 2× (one-hour TTL) — and the cache is a strict prefix match, so prompt structure matters. OpenAI discounts cached input by 90% with cache writes at 1.25× the uncached rate. Gemini prices explicit context caching per token plus an hourly storage fee. All three also run discounted asynchronous batch tiers — 50% off both directions on all three vendors — which is free money for anything that can tolerate a delay. I walk through the full mechanics, with worked examples, in LLM API Pricing, Explained.

Tool use and agentic reliability

If your product is an agent — a model calling tools in a loop, in the sense I unpack in What Are AI Agents, Actually? — then the property you are buying is not knowledge, it is reliability under iteration. Can the model follow a tool schema exactly, recover when a call fails, notice when it is going in circles, and stop when the job is done? Leaderboard scores capture almost none of this, and it is where the families differ most in ways that only show up in your own harness.

All three vendors now train hard on tool use, and all three support the Model Context Protocol (modelcontextprotocol.io), which matters for the decision in a quiet way: if your tools are MCP servers, your integration layer is portable across providers, and switching models stops being a rewrite. I cover how that works in What Is MCP? The practical test is unglamorous: wire two candidate models into your actual agent loop and count failed tool calls per hundred turns. That number will settle the argument faster than any benchmark chart.

Ecosystem, data retention, and compliance

Sometimes the model choice is made outside engineering. Each family is entangled with a cloud: Gemini with Google Cloud and Vertex AI, OpenAI with Azure, and Claude available through the major cloud marketplaces as well as directly. If your company already has a cloud commitment, buying inference through it can mean consolidated billing, existing security reviews, and spend that counts toward negotiated commitments — advantages that have nothing to do with model quality and frequently decide the vendor anyway.

Data handling deserves the same scrutiny. All three publish retention and training policies for API traffic, and enterprise agreements can tighten them further; if you operate under HIPAA, GDPR, or financial-services rules, read the current policy documents rather than relying on a blog post — including this one. The right time to discover a retention constraint is before the pilot, not during procurement review.

Benchmark on your task, and design for the swap

The most underrated advice in model selection: public benchmarks measure the vendor’s ability to do well on public benchmarks. Your task is not on the leaderboard. Build a small eval set — even fifty to two hundred real examples pulled from your actual traffic, graded against a rubric — and run the candidate tier from each family against it. This costs an afternoon and a few dollars, and it replaces argument with data. Rerun it when a new model ships.

Then assume you will switch, because you probably will. Keep provider calls behind a thin adapter, keep prompts in versioned files rather than scattered through code, and treat provider- exclusive features as consciously accepted lock-in rather than accidental dependencies. Prompts do not port cleanly — budget re-tuning time into any migration — but a codebase that can point at a different model in a day turns every price cut and model release into leverage instead of a rewrite.

Bottom line

• Pick the tier first: mid-tier models (Sonnet 5, Terra, 3.6 Flash) are the right default for most product work; reserve frontier models for the hardest problems and small models for volume.
• Price your actual traffic shape — input vs. output mix, caching, batch — not the headline number, and remember long context is surcharged past roughly 200–272K tokens on Gemini and GPT.
• For agents, measure tool-call reliability in your own loop; for everything else, run a small eval on your own data.
• Let ecosystem, retention, and compliance constraints filter the list early — they are cheaper to discover before the pilot.
• Design for swappability. As of August 2026 the price-performance frontier moves every few weeks; the durable advantage is being able to follow it.