Choosing an AI model: there is no single race.

"Which model is best" has stopped having an answer. "Which model for this job" has never been easier to answer.

An earlier version of this article was a leaderboard: nine models, ranked, with confident superlatives. It was outdated within a quarter — names changed, prices halved, context windows moved, and two of the "contestants" shipped successors. That taught us the lesson this rewrite is built on: model names have a shelf life measured in weeks; selection criteria last for years.

We still get asked roughly every week which model a client should "go with." The honest answer in 2026 is that the question is wrong — not because models don't differ, but because they differ by workload. This is the version of the answer we wish we could print on a card and hand over.

There is no single race

The frontier is not one race with one finish line. It is half a dozen races run simultaneously: raw reasoning depth, coding and agentic reliability, latency, price per token, context length, multimodal understanding, and deployment freedom. Different models win different races, and — this is the part the leaderboards hide — your product only runs in two or three of them.

A frontier reasoning model losing a price-per-token comparison to a small fast model is not news. Neither is the small model losing a hard-reasoning comparison. Asking "which is best" without naming the workload is asking whether a sports car beats a moving van. It depends on what you're carrying.

The landscape, dated and disposable

Model landscape checked: August 8, 2026. This section will go stale first; that is why it is short and the rest of the article is not about names.

As of this writing, three closed labs sit at the front. Anthropic ships the Claude 5 family — a new top tier above Opus, with Sonnet and Haiku below it — and remains the reference point for long, multi-step agent work. OpenAI runs the GPT-5.x line with the broadest tool ecosystem and enterprise distribution. Google pushes the Gemini 3 line, strong on images and video and on grounding answers in search.

On the open-weight side — models you can download and run yourself — DeepSeek's API lists V4 Flash and V4 Pro, with Llama and Qwen as the other defaults. Moonshot's Kimi K2.6 offers a 256K-token context window and strong bilingual performance. MiniMax shipped its M3 line in June 2026, pitched on a million-token context window and agentic coding.

Treat every sentence in that paragraph as perishable. What doesn't perish is the shape of the field: two or three closed frontier providers, a maturing open-weight ecosystem, regional champions with real strengths, and a fast tier from every lab where most production volume actually lives.

The axes that actually decide it

Raw benchmark scores get all the press and almost none of the procurement weight. Inside the actual model-cards-and-pricing-tables of every lab, the race is on a much messier set of axes:

Context length. Headline windows raced from 200K past a million tokens, and the marketing numbers keep climbing. Most teams discovered, with some embarrassment, that they didn't actually need the headline — what they needed was reliable retrieval at the context length they already had. But the labs ship the big number anyway, because it converts.

Prompt caching. Anthropic and Google made cached input dramatically cheaper than fresh input, and the entire "long system prompt" pattern reorganised around it. If your usage pattern includes repeated context (it almost certainly does, in any agent), caching is now a first-class architectural decision.

Agent building blocks. Sub-agents, control of a computer, code run in a sandbox, memory that survives a session. The labs have visibly different strengths here. In our own agent work, Anthropic's stack has been the most dependable for sub-agents and tool reliability, OpenAI's for realtime voice and app surfaces, Google's for reading images and video. None of them are interchangeable yet, and the gaps move with every release.

Tool-use consistency. The forgotten metric. A model that uses tools correctly 99% of the time will out-ship a model that reasons better but gets tools right 95% of the time. In a long chain of steps, small error rates compound fast. We grade every model we adopt on this before any other axis.

MCP support. The Model Context Protocol, released by Anthropic and now handed to the Linux Foundation, is close to universal: OpenAI, Google, Mistral and the open-weight ecosystem all speak it. It lets you bring your own tools to whichever model you're using this week. That is the single biggest levelling force in the model market right now.

Open weights. DeepSeek, Llama, Qwen lead. The political case — sovereignty, audit, data residency — matters more than the technical case for many enterprise procurements in 2026.

Latency tiers. Every lab now ships a small, fast, cheap tier — Haiku, Flash, mini, Lite. The fast tier is where most of the volume lives in production. The headline model is the marketing.

Per-token pricing. A real war. Cached-input pricing keeps falling, and the price floor on commodity classification work has dropped by an order of magnitude in eighteen months. Whatever number we print here would be wrong by the time you read it — which is itself the point: price is a quarterly review item, not a one-time decision.

A selection framework that survives launches

Here is the process we actually run with clients. It takes an afternoon, and it doesn't expire when a lab ships something new.

Step one: name the workloads. Not "we need AI" — the actual list. Interactive chat, long agent loops, bulk classification, document extraction, code generation, voice. Each workload gets its own selection; pretending they're one decision is where most model-choice arguments come from.

Step two: apply the hard constraints first. Data residency, on-prem or sovereign deployment, latency budget, cost ceiling, context requirement. Constraints are wonderful: they eliminate most of the field before anyone argues about quality. A sovereignty requirement alone takes you straight to the open-weight ecosystem and ends the debate.

Step three: run your own eval on the two or three survivors. Fifty to a hundred real tasks from your product, a written rubric, a date on the results. Public benchmarks tell you a model is competent in general; they cannot tell you it is right for your workload. Any "best by a margin" claim — including ours — should come with a date, a task count and criteria attached, or be ignored.

Step four: re-run quarterly. Not on launch day, not when the demo drops on your feed. Quarterly. The eval set is the durable asset; the winner is allowed to change.

Route, don't marry

Three rules survive the churn.

One: don't bet on one model. The shape of the field six months from now will not be the shape today. Build a model-adapter layer in your code — a single interface, multiple implementations — and treat the choice of model as runtime configuration, not an architectural assumption. Every team we work with that ignored this advice in 2024 paid for the migration in 2025.

Two: choose by workload, not by brand. Our own eval set is about forty production-shaped tasks, scored on completion and correctness, last run in July 2026. On that set, the top reasoning tiers earn their price on long agent runs and complex code review — and nowhere else. Cheap classification and structured extraction live happily on the fast tiers. Sovereign deployments go open-weight. Long-document question answering goes to whichever provider's retrieval actually holds up on your documents. Pick the model the way you'd pick a database: by the workload, not the logo.

Three: hybridise by capability, not loyalty. The best production AI systems we ship in 2026 use three or four models in the same request, not one. A small fast model for routing. A mid-tier model for the bulk of the response. A frontier model for the hard step. A separate tiny model for the structured-output guardrail. The composition is the architecture; no individual model is the architecture.

The bigger pattern

Six months from now the landscape section of this article will be stale — that's why it is short and date-stamped. At least one lab will have shipped something we didn't see coming. That is not an argument against having an opinion now. It is an argument for having an opinion that survives whichever logo leads next quarter: criteria, constraints, your own evals, and an architecture that routes.

Meanwhile, every lab now ships a developer surface alongside its model — a command-line tool, an agent SDK, an app platform. Developers are the multiplier: one who adopts your model tends to bring their company onto it. The smart buyers in that fight are the routing layers above the models, which quietly pick the best model per task and keep their contracts open. You can be a smart buyer too. That is what the adapter layer is.

The developer wars are the strategic prize, because developers compound. But whoever wins them, the teams that keep their evals fresh and their routing loose will barely feel the transition. The races are real. The scoreboard is not your architecture. Don't confuse the two.