The model landscape, minus the marketing

This one is a reading entry, not a building one. I spent the day reading around current AI models – how they actually differ when you use them, and what they cost to run. No code, no repo. The goal was to replace a vague sense of the landscape with something I can make decisions from, because the vague sense was all I had and it was not decision-grade.

Worth saying plainly: the apprenticeship does not touch any of this. The course gives me full-stack development, project process, the academic side of the discipline. Choosing a model or budgeting for one is somebody else’s problem right up until it is mine – and for anything I build that calls an API, it already is mine.

I first wrote this up without numbers, on the grounds that they would date. That was the wrong call: without them there is nothing to reason with. Every figure below is a published rate read on 25 August 2026, sourced at the end. Where a vendor prices in yuan I give the native figure and convert at 1 USD = 6.7198 CNY, the ECB reference rate for that date. Several prices have a documented expiry, which turns out to be part of the point.

The price card, as it actually stands

Per million tokens, standard tier, USD:

Model	Input	Output	Cache read
Claude Opus 5	$5.00	$25.00	$0.50
Claude Sonnet 5	$2.00	$10.00	$0.20
Claude Haiku 4.5	$1.00	$5.00	$0.10
gpt-5.6-sol	$4.00	$20.00	$0.40
gpt-5.6-terra	$2.00	$12.00	$0.20
gpt-5.6-luna	$0.20	$1.20	$0.02
Gemini 3.7 Flash	$0.75	$3.75	$0.075

Output costs five to six times input at every tier of every vendor – exactly 5x across Anthropic’s whole ladder, 5x on gpt-5.6-sol, 6x on terra and luna, 5x on Gemini 3.7 Flash. Cache reads are a tenth of base input at both Anthropic and OpenAI, independently, which is a suspiciously round consensus.

The 5-to-6x output multiplier is the most useful number here, because a model that waffles costs more per task than one that answers tersely even when their input prices match. Reasoning models make that worse deliberately: thinking happens in tokens, those tokens bill at output rates, and you do not see them. Google is the most honest about it, labelling the row “Output price (including thinking tokens)“.

The number that is not on the price card

The best thing I read all day was a footnote. Claude 4.7 and later use a new tokeniser that produces roughly 30% more tokens for the same text than 4.6 and earlier.

Opus 4.6 and Opus 4.7 both list at $5 in and $25 out. So the same document, sent to both, costs about 30% more on the newer one. An unchanged price card describing an effective input rate of about $6.50. Nothing dishonest is happening – the tokeniser change is documented and it buys better performance – but if you are comparing vendors on a spreadsheet of dollars per million tokens, you are comparing units that are not the same size.

The expiry dates matter for the same reason. Gemini 3.7 Flash is $0.75 in and $3.75 out through 31 December 2026, then doubles. gpt-5.6-sol’s rate is promotional through at least 21 November 2026. Sonnet 5 went the other way: its $2 and $10 introductory pricing was scheduled to rise to $3 and $15, and that rise was cancelled. Any snapshot of this table is a snapshot of a negotiation in progress.

Caching is a design decision, not a micro-optimisation

Take an agent loop over a codebase: a 50,000-token stable prefix, 2,000 new input tokens and 1,000 output tokens per step. On Opus 5, with the prefix cached, a step costs 5 cents of cache read, 1 cent of new input and 2.5 cents of output – $0.06. Without caching, that same step resends the prefix at full rate: $0.285. Over 500 steps that is $30 against $142.50, for identical work. Caching is not a 10% saving, it is a 4.75x one, and it exists only because agent loops resend the same context over and over.

The rung matters less than the pattern does. The same cached step is $0.024 on Sonnet 5 and $0.012 on Haiku 4.5 – Haiku is 5x cheaper than Opus, but the uncached Opus loop is nearly 24x the cached Haiku one. Fixing the usage pattern beats moving down the ladder.

The vendors charge for caching in structurally different ways. Anthropic and OpenAI both take a premium at write time – 1.25x base input for a five-minute cache, 2x for an hour – then charge a tenth of input on reads, so a five-minute cache pays for itself after one hit. Google instead charges rent: a cheap read plus $0.50 per million cached tokens per hour of storage. For a long-lived session that sits idle between bursts, Google bills you for wall-clock time you were not using. Same feature, different failure mode.

Where the frontier vendors diverge

Context length is priced by OpenAI and not by Anthropic. gpt-5.6-sol costs $4 in and $20 out on short context and $8 in and $30 out on long – input doubles as the window grows. Anthropic states the opposite explicitly: the full million-token window is standard-rated, and “a 900k-token request is billed at the same per-token rate as a 9k-token request”.

The ladders are not the same width. Top to bottom of Anthropic’s line-up is 5x on input. OpenAI’s spans gpt-5.5-pro at $30 down to gpt-5.6-luna at $0.20 – 150x. A wide ladder is worth more than a cheap flagship if your workload splits into hard and trivial work.

The other half of the market

Everything above assumes you are renting tokens from a lab that will not show you its weights. There is a second market where the weights are downloadable, and it is not a fringe: DeepSeek, Moonshot, Zhipu, Alibaba and MiniMax in China, Mistral in France, and OpenAI’s own gpt-oss release all publish weights you can pull from Hugging Face today.

Here is the same 500-step agent loop, priced across both markets:

Two things in that chart surprised me, and both break the story I expected to be telling.

“Chinese lab” does not mean cheap. Kimi K3 lists at $3.00 cache-miss input and $15.00 output – only 1.67x cheaper than Opus 5 on this loop, and dearer than GLM-5.3. Moonshot is not competing on price at the top of its range. Meanwhile the cheapest serious open-weight option in the chart that is not Chinese, Mistral Large 3 at $0.50 in and $1.50 out, comes in at 12x cheaper than Opus 5 and beats both Kimi and GLM. If you frame this as China-versus-the-West you get the answer wrong.

DeepSeek is the outlier, and its price card has a shape nobody else’s has. V4-Pro is $0.66 in and $1.98 out off-peak. Three structural differences from the frontier: output is 3x input rather than 5-6x; a cache hit is one thirtieth of a cache miss rather than one tenth, a 96.7% discount stated on the face of the price card; and caching is entirely free, with no write premium and no storage rent. Then there is the off-peak scheme, which is inverted from the discount window you would expect. Peak is only Monday to Friday, 01:00–04:00 and 06:00–10:00 UTC – 35 hours, 20.8% of the week. Everything else, including all weekend, is half price. The default state of the week is the discount. Run the loop on V4-Flash off-peak and it costs 73 cents against Opus 5’s $30, a 41x gap.

What the licences actually say

“Open weights” is not one thing, and this is where reading the actual licence files rather than the marketing pays off. There are four distinct regimes in play.

Genuinely permissive, OSI-approved. DeepSeek ships V4-Pro and V4-Flash under plain MIT – no acceptable-use policy, no user threshold, no attribution requirement, and no anti-distillation clause. Zhipu does the same across the open GLM line, and says so as a selling point: “Pure Open: an MIT open-source license, no regional limits”. Mistral uses Apache 2.0 for Large 3, Small 4 and Ministral 3; OpenAI’s gpt-oss is Apache 2.0 too. These are the only ones where the licence itself clears the open-source bar.

Attribution above a threshold. Kimi K2 through K2.7-Code use a “modified MIT” – standard MIT plus one paragraph requiring you to display the model’s name in your UI if your product exceeds 100 million monthly active users or $20M monthly revenue. A naming credit, no fee, no permission needed. Alibaba’s flagship Qwen3.8-Max licence has a similar attribution trigger at the same thresholds.

Permission required above a threshold. This is the category that actually bites, and it is growing. Kimi K3 dropped the modified-MIT text for a bespoke licence adding a Model-as-a-Service clause: an inference provider whose revenue exceeds $20M over any rolling twelve months “must enter into a separate agreement with Moonshot AI before using the Software or its derivative works for any commercial purpose”. Mistral’s Medium 3.5 is the same idea at a harsher threshold – above $20M monthly revenue you buy a commercial licence or use Mistral’s own hosting. Qwen3.8-Max requires a separate licence for Model-as-a-Service above $50M over twelve months. Note the trap in Kimi’s file: clause 2 says $20M per twelve months and clause 3 says $20M per month. Same document, different tests.

Not commercial at all by default. MiniMax M2.7 shipped under a non-commercial licence requiring prior written authorisation for any commercial use, no threshold. M3 relaxed that to a community licence with attribution plus a $20M-per-year authorisation trigger and a prohibited-uses appendix that includes military use. Two consecutive releases from one lab, materially different rights.

And then Meta, which is the interesting case precisely because it is the one everybody names. Llama 4’s Community Licence is not OSI-approved: a 700-million-MAU cap above which you must ask Meta for a licence granted “in its sole discretion”, a duty to display “Built with Llama”, a requirement to prefix the name of any model you train on Llama outputs with “Llama”, an acceptable-use policy incorporated by reference, and California law and jurisdiction. Meta’s current flagship is not open weights at all – it is served through an API with no download link. If your mental model is “Meta is the open one and the Chinese labs are the closed ones”, it is exactly backwards on both halves.

None of these labs publishes its training data. Every one of them is open weights, not an open-source model in the reproducible sense. MIT describes the artefact you downloaded, not how it was made.

What you give up

This is the honest cost column, and it is not the one the geography suggests.

Training on your inputs. DeepSeek’s disclosure says optimisation data is partly “based on user input”, with opt-out by emailing them – no self-serve toggle, no API carve-out. Moonshot’s terms are blunter: content “may be used” to improve the services, and restricting that means negotiating an enterprise agreement. Both are the opposite of the OpenAI and Anthropic API defaults. But Zhipu’s international DPA goes further the other way than any frontier lab: it states they “do not store any of the content the Customer or its End Users provide”, not saved on their servers at all. The privacy ranking does not follow the flag.

The clearest evidence that this is a priced feature rather than a principle comes from Meta. Its Muse Spark 1.2 has two rates for the same model: a “contributor” tier at $0.10 input and $0.20 output that is used to improve Meta’s products, and a standard tier at $1.25 and $4.25 that is not. That is a 12.5x input and 21x output premium for opting out of having your data train the model – the most explicit price a major lab has yet put on data privacy.

Jurisdiction, which is less exotic than expected. DeepSeek is a PRC contract: mainland law, Hangzhou courts, data processed and stored in the PRC. But Moonshot’s international platform is a Singapore company with Singapore servers under Singapore law and SIAC arbitration, and Zhipu’s international entity is Singapore-domiciled too. “Chinese lab” and “your data goes to China” are separable questions, and for two of the three they separate.

Operational maturity. Neither DeepSeek nor Zhipu publishes numeric rate limits; DeepSeek’s limits are concurrency-based with no RPM or TPM figures at all, and Zhipu’s are visible only once you are logged in. Model lifecycles are short and brutal – Moonshot switched off the entire Kimi K2 API line in May 2026 and sunsets moonshot-v1 at the end of this month. And there is a subtler one: Moonshot publishes a tool called Kimi-Vendor-Verifier for checking whether a third-party host is serving its models at the correct precision. The lab itself acknowledges that identical weights served by someone else may not behave identically.

The frontier is still the frontier, and they say so. Zhipu’s own GLM-5.3 write-up concedes that on its internal coding benchmark “GLM-5.3 remains behind Claude Fable 5”, and that on exploit benchmarks “the further up the exploitation chain a benchmark sits, the wider the remaining gap to the closed frontier”. That is a vendor volunteering the gap in its own launch material, which is worth more than any leaderboard.

A genuine, underrated pro: DeepSeek’s terms explicitly permit using its outputs to train other models, “such as model distillation”. Most Western licences prohibit exactly that, and Llama’s naming clause is designed to catch it. If you want to build a small specialised model, that clause is worth more than the price difference.

Self-hosting, with the arithmetic

Free weights are not free inference, and the numbers are less romantic than the licences.

Lambda’s on-demand list price is $3.99 per GPU-hour for H100 SXM in an 8-GPU configuration – $31.92 an hour for the node, $766 a day, $23,302 for a 730-hour month. At DeepSeek V4-Pro’s off-peak output rate of $1.98 per million tokens, that month of hardware costs the same as 11.8 billion output tokens of API. On V4-Flash it is 35 billion. Unless you are serving at genuinely large scale, renting the model is cheaper than renting the machine, and by a margin that is not close.

It is also worth checking whether the model even fits. DeepSeek V4-Pro is 1.7 trillion parameters total; Kimi K3 is 2.8 trillion. Neither goes on one 8×H100 node. The models that genuinely are self-hostable are the small ones, and that is where the story improves: gpt-oss-120b has MXFP4 quantisation baked in before OpenAI ran its own evals, which lets it run on a single 80GB GPU – one H100 at $4.29 an hour, about $3,132 a month, and gpt-oss-20b fits in 16GB. Mistral’s stated floor for Small 4 is four H100s. Zhipu’s GLM-4.7-Flash is a 30B mixture-of-experts under MIT and is free on Zhipu’s own API, which makes the self-hosting question moot until you need the control.

So the real reasons to self-host are not cost: data never leaving your infrastructure, no vendor able to retire the model under you, no rate limits, and the freedom to fine-tune. Those are good reasons. Saving money at small scale is not one of them.

Three vendors, one benchmark, three harnesses

A note on reading any of the scores these labs publish, and a correction to the earlier version of this piece.

There are two different things called DeepSWE. DeepSWE-Preview is a model: a 32B coding agent from the Berkeley Sky Computing Lab and BAIR with Together AI, built on Qwen3-32B and trained purely with reinforcement learning, released under MIT in 2025. It resolves 42.2% of SWE-bench Verified on a single attempt and 59.0% with 16 attempts and a verifier – the top open-weights result when it was published, and still the cleanest demonstration that RL alone can take a mid-size open model to a competitive agentic score.

DeepSWE is also, separately, a benchmark – 113 original long-horizon tasks from Datacurve, published July 2026. Its design is a direct answer to the contamination problem: tasks are written from scratch across 91 active repositories in five languages and deliberately never contributed upstream, so the reference solutions stay out of what training scrapes, and each is graded by a hand-written verifier that accepts any implementation with the right observable behaviour rather than by the tests that shipped with one particular merged fix. The paper reports that an independent LLM judge disagrees with DeepSWE’s verifiers on 1.4% of graded runs against 32.4% for SWE-Bench Pro’s inherited tests. That is the more interesting number in the paper.

Now the trap. Three labs report a DeepSWE v1.1 score on their own model cards: GLM-5.3 at 66.9, Kimi K3 at 67.5, DeepSeek V4-Pro at 62.7. Those three numbers are not comparable. GLM’s was measured inside Claude Code at maximum reasoning effort; Kimi’s on Moonshot’s own Kimi Code harness; DeepSeek’s on DeepSeek’s own harness in minimal mode at maximum effort. The benchmark’s public leaderboard uses mini-swe-agent for everyone, and Kimi is the only one of the three to also disclose its mini-swe-agent figure – 67.3, a fifth of a point lower. Moonshot volunteers elsewhere that a harness change alone moves one of its scores by 0.8 points and that some agentic results were measured on H20 GPUs rather than H100s.

Which is the general lesson, and the one I actually took from the day: on a vendor’s own card, the harness is part of the claim. A score without one is a number without a unit.

The shape I ended up with: cheap fast model for bulk steps wherever a mechanical check catches the failures, expensive model for planning and for whatever the cheap one flags as hard, caching on by default because it is worth more than the model choice, and an open-weight model wherever the licence is MIT or Apache and the data policy survives reading. The specific figures here will be wrong within months – several have a documented date on which they change. The ratios and the structures have held across every price list I looked at, and those are what I will actually make decisions with.

Sources

All prices and licence texts read on 25 August 2026. Conversions from CNY use the ECB reference rate for that date, 1 USD = 6.7198 CNY, from Frankfurter. The per-step and per-500-step costs, and the self-hosting break-even, are my own arithmetic over these published rates.

Frontier APIs

• Claude API pricing – model rates, prompt-caching multipliers, the 50% Batch discount, the Claude 4.7 tokeniser note, flat-rate long context.
• OpenAI API pricing – short and long context rates, cached input, Batch, Flex and Fast tiers.
• Gemini Developer API pricing – tiers, context-caching storage price per hour, and the dated price changes.

Open-weight labs

• DeepSeek pricing and the Chinese price card – RMB-native rates, the peak and off-peak windows, cache-hit and cache-miss columns. KV cache guide for the free-caching mechanics; terms and privacy policy for jurisdiction, training-on-input and the distillation permission; V4-Pro and V4-Flash model cards for MIT and parameter counts.
• Kimi K3 pricing and model list; the Kimi K3 licence and the modified-MIT licence it replaced; K3 model card for architecture, benchmarks and harness notes; terms and privacy policy for training-on-input and the Singapore entity; Kimi-Vendor-Verifier.
• Z.ai pricing and bigmodel.cn pricing for the international and domestic lists; coding plans for the credit system and off-peak rule; GLM-5.2 and GLM-5 cards for MIT and architecture; the GLM-5.3 launch post for the benchmark caveats and the concession to the closed frontier; privacy policy and DPA for the no-storage clause.
• Alibaba Cloud Model Studio pricing and the Qwen3.8-27B card (Apache 2.0); the Qwen3.8-Max licence for its attribution and Model-as-a-Service triggers.
• MiniMax pricing, the M3 community licence and the M2.7 non-commercial licence it replaced.
• Mistral pricing, the Mistral 3 release for Apache 2.0 and architecture, and the licence FAQ for the modified-MIT revenue threshold.
• gpt-oss-120b for Apache 2.0, MXFP4 and the single-GPU claim, and its API model page, which documents zero throughput on every tier.
• Llama 4 Community Licence for the 700M-MAU cap, the “Built with Llama” duty and the naming clause; Llama 4 model cards; Muse Spark 1.2 for the contributor-versus-standard pricing split.

Benchmarks and hardware

• DeepSWE: Measuring Frontier Coding Agents on Original, Long-Horizon Engineering Tasks – the benchmark paper, and its repository for the task format and the mini-swe-agent leaderboard harness.
• agentica-org/DeepSWE-Preview – the model, its SWE-bench Verified scores and the open-weights comparison table behind the second chart.
• SWE-bench – Verified is the human-validated 500-problem subset.
• Lambda GPU pricing – on-demand H100 and B200 per-GPU-hour rates used in the self-hosting arithmetic.