Here is the year, and what it means for the next one.

the releases that mattered#

DeepSeek R1 (January). MIT license, published training methodology, distilled variants that ran on consumer hardware. The RL-on-verifiable-rewards recipe was reproduced widely within weeks.

Qwen3 (April). Eight models, Apache 2.0, MoE variants with excellent quality-per-active-parameter, 119 languages.

Kimi K2 (July). A trillion parameters, open weights, tuned for agentic tool use, with a genuinely novel training stability contribution.

gpt-oss (August). OpenAI's first open weights since 2019, Apache 2.0, with a 20B variant that runs on a laptop.

Plus continuous releases from Mistral, Zhipu, MiniMax, Meta, Microsoft, Google, and a long tail of fine-tunes.

where the gap actually is#

The frontier-to-open gap held at roughly six to twelve months all year. That stability is the most important finding, because it means open weights are not converging on the frontier and are not falling behind — they are trailing at a fixed distance.

But "six months behind" undersells the practical position, because the gap is not uniform:

Nearly closed: code completion, summarization, extraction, classification, translation, structured output, straightforward tool use. For these, a good open model is not meaningfully worse than a frontier model, and it costs a fraction.

Meaningfully behind: long-horizon agentic work, complex multi-step reasoning, instruction following over many turns, reliability at the tail. This is where frontier models earn their price.

Not comparable: anything requiring the surrounding infrastructure — enterprise support, uptime guarantees, safety tooling, indemnification. Open weights give you the model and nothing else.

what changed structurally#

Licensing got genuinely permissive. Two years ago "open" meant a research license with a prohibited-use list. Now the frontier of open releases is Apache 2.0 and MIT. That is a real change and it removed the legal review that was blocking adoption.

The runtime story got boring. Ollama, llama.cpp, vLLM, MLX, LM Studio. One command. An OpenAI-compatible endpoint. The friction that kept open models in the enthusiast category is gone.

Hosting became competitive. Multiple providers serve open models at prices well below frontier API rates, with real SLAs. You can use open weights without running anything.

The center of gravity moved east. The most capable, most permissively licensed open releases came predominantly from Chinese labs. That is a strategic fact with policy consequences that are being worked out loudly and mostly unproductively.

the practical architecture for next year#

The shape that makes sense:

• Open weights, self-hosted or on a cheap provider, for high-volume, well-defined tasks. Classification, extraction, embedding, first-pass drafting.
• Frontier API for the hard tail: planning, complex reasoning, anything customer-facing where a bad answer is expensive.
• A router deciding between them, with the escalation rate instrumented.
• Your own eval set in your own repository, run against every candidate.

That is not a hedge. It is what the cost and capability curves actually imply.

the prediction#

The gap holds at roughly six to twelve months through next year. Open weights absorb an increasing share of production workload by volume while frontier models keep the high-value tail.

The interesting question is not capability. It is whether the labs currently releasing weights continue to, and that is a business decision that could change in either direction with one quarter's strategy review.

Download the ones you care about. They cannot be un-released.

the specs#

Both are mixture-of-experts with configurable reasoning effort:

• gpt-oss-120b — 117B total parameters, ~5.1B active. Fits on a single 80 GB accelerator with the provided MXFP4 quantization.
• gpt-oss-20b — 21B total, ~3.6B active. Runs on a machine with 16 GB of memory.

That second one is the important number. 16 GB is a well-specified laptop. A reasoning model with tool use and a configurable thinking budget that runs on a laptop, under Apache 2.0, from OpenAI, is a sentence that would have been implausible eighteen months ago.

Reasoning effort is set in the system prompt — low, medium, or high — which is a cruder interface than a token budget but works.

the format#

The models use a "harmony" response format with structured channels separating analysis, commentary, and final output. You have to render it correctly or the model behaves poorly. The reference implementations handle it; if you are writing your own serving path, read the format spec first rather than debugging it later.

They support tool use — browsing and Python execution — natively, and function calling in the standard shape.

why now#

Three reasons, in descending order of how much anyone will admit them.

Competitive pressure. The open weights frontier is currently defined by DeepSeek, Qwen, Moonshot, and Mistral. A company named OpenAI having no open models had become a running joke and, more importantly, a strategic gap — the developers building on open weights were building on someone else's ecosystem.

Policy positioning. There is an active regulatory conversation about open models. Being a participant with skin in the game is worth more than commenting from the sidelines.

The capability gap has closed enough to be safe and stayed wide enough to be commercial. Releasing a model at roughly o3-mini level costs OpenAI little in API revenue — the customers who need frontier capability still need it — and buys a lot of ecosystem.

how good are they#

Genuinely competitive in their size class. The 120b is roughly comparable to o3-mini on reasoning benchmarks; the 20b is close to o3-mini on several and weaker on others.

The caveats are the usual ones for open weights: they hallucinate more than frontier models, the safety tuning is more easily removed by fine-tuning (OpenAI published research on this specifically), and benchmark performance overstates real-world reliability.

what to do with them#

The 20b is the interesting one for most developers. Concretely:

• Local coding assistance with no data leaving the machine. This clears the legal review that blocks hosted models at a lot of companies.
• Batch processing where you have a lot of documents and API costs add up. Run it on a spot instance overnight.
• Fine-tuning for a narrow domain. Apache 2.0 means you can, and a fine-tuned 20b on a specific task frequently beats a general frontier model on that task, for a fraction of the cost.

ollama run gpt-oss:20b

That is the whole setup. The ecosystem picked it up within hours of release, which is itself a demonstration of why open weights are worth releasing.

the broader point#

Two years ago the argument was "open models are dangerously behind or dangerously capable, pick one." The answer turned out to be: they trail the frontier by roughly six to twelve months, that gap is stable, and the world has not ended.

The gap being stable is the interesting finding. It means open weights are permanently a viable option for anything that does not need the absolute frontier — which is most things.

A trillion-parameter open weights release is a milestone regardless of what you think of the benchmarks.

the architecture#

384 experts, 8 selected per token, 32B active. The design point is explicit: get the knowledge capacity of a very large model with the inference cost of a mid-sized one.

The training used MuonClip, a variant of the Muon optimizer with a QK-clipping mechanism to prevent attention logit explosion. The reported claim is zero loss spikes across the entire pretraining run on 15.5 trillion tokens.

If you have not run large pretraining: loss spikes are the recurring nightmare. A run destabilizes, you roll back to a checkpoint, you lose days of compute, and diagnosing why is largely folklore. A stability technique that actually works is worth more to the field than a benchmark point.

the agentic focus#

K2 was post-trained specifically for tool use, on synthetic multi-step tool-use trajectories generated at scale. The evaluation emphasis is agentic coding and tool-calling benchmarks rather than conversational quality.

That focus is the right read of where the demand is. The commercially interesting use of a model in 2025 is not answering questions, it is executing multi-step tasks with tools, and models tuned for chat are frequently worse at it than their raw capability suggests.

the practical problem#

You cannot run this on a workstation. A trillion parameters at 8-bit is a terabyte of weights. Even heavily quantized you are looking at multiple high-memory GPUs or a very large server.

So "open weights" here means something different than it does for a 30B model. It means:

• Hosting providers can serve it, and several did within days, at prices well below frontier API rates.
• Companies with infrastructure can run it privately, which is the point for regulated industries.
• Researchers can study it, which is the underrated benefit. Interpretability work on frontier-scale models has been limited to whoever works at a frontier lab. It does not have to be.

the license#

Modified MIT with an attribution clause above certain usage thresholds. Not strictly OSI-compatible, much closer to open than most "open" model licenses, and substantially more permissive than the Llama community license.

The trend line here is good. Two years ago open weights meant a research-only license with a list of prohibited uses. Now the frontier of open releases is MIT and Apache 2.0 with narrow carve-outs.

the pattern nobody should miss#

The most permissively licensed, largest, most capable open weights models are overwhelmingly coming from Chinese labs — DeepSeek, Qwen, Moonshot, Zhipu, MiniMax. Western open weights releases have been smaller and more restrictively licensed.

The strategic logic is not complicated: if you are behind on distribution, you compete on openness. It worked for Meta in 2023 and it is working now.

The practical consequence for a developer is that your best option for a private, self-hosted, high-capability model is increasingly a Chinese release. Evaluate it on your own tasks, run it in your own infrastructure, and make the decision on engineering grounds.

The license is the headline. Apache 2.0 with no user threshold, no naming requirement, and no acceptable-use addendum that functions as a license restriction. You can fine-tune it, ship it, sell it, and never mention where it came from.

the lineup#

The MoE variants are the interesting ones. 30B-A3B has 30 billion total parameters and activates 3 billion per token. That means memory footprint of a 30B model and inference cost closer to a 3B model. On a machine with enough RAM to hold it, throughput is dramatically better than a dense model of comparable quality.

For local deployment this is the shape that matters. Memory is cheap and getting cheaper; compute per token is the thing you feel.

hybrid thinking#

Every model supports two modes: thinking and non-thinking, switchable per request. You can also switch mid-conversation with a token in the prompt — /think and /no_think — which is a hacky interface and also extremely practical.

text = tokenizer.apply_chat_template(
    messages, tokenize=False, add_generation_prompt=True,
    enable_thinking=True,     # or False
)

The design conclusion the field has reached, from three different labs independently, is that reasoning should be a runtime dial rather than a model choice. That is now clearly correct and I expect it to be universal within a year.

multilingual coverage#

119 languages and dialects, which is a genuinely differentiating number. Most open models are strong in English, decent in a handful of European languages, and degrade sharply after that. If you are building for a market outside the usual list, this is worth evaluating specifically.

the geopolitical thing#

A large share of the best open-weights models now come from Chinese labs — Qwen, DeepSeek, GLM, Kimi, MiniMax. That is a real shift from two years ago when open weights meant Llama and Mistral.

The engineering reason is straightforward: releasing weights is a good strategy when you are not the market leader, because it buys mindshare, ecosystem, and research feedback that you cannot get otherwise. Meta understood this in 2023. Chinese labs understand it now.

The policy conversation around this is loud and mostly not technical. What is technical, and worth being clear about: weights are weights. A downloaded model runs on your hardware, in your VPC, with no network egress. The supply chain questions worth asking are about what the model does — evaluate it for backdoored behavior, test it on your own adversarial cases — not about where the gradient descent happened.

what to actually do#

If you are running anything local, the 30B-A3B is the current best quality-per-watt option for a workstation. If you are fine-tuning, Apache 2.0 removes the legal review that was blocking you.

Download it before someone decides you cannot.

Within forty-eight hours the release turned into a story about benchmark integrity instead.

what happened#

Maverick posted a very strong score on LMArena, the human-preference leaderboard. It then emerged that the model evaluated on the arena was an "experimental chat version" tuned for conversationality — not the checkpoint released to the public. LMArena updated its policies and published the disputed comparison. Meta's response was that experimental variants are normal and the arena version was labeled.

Both of those things can be true and the outcome is still bad, because the number that traveled was attached to a model nobody could download.

why this keeps happening#

Leaderboards are the only shared vocabulary the field has, and they are being asked to carry weight they cannot bear.

• Human preference arenas measure whether people like the answer. That correlates with quality and also with formatting, length, confidence, and sycophancy. A model tuned to be agreeable climbs.
• Static benchmarks leak into training data. Every popular benchmark is on the internet and every frontier model has read the internet. Contamination is not always deliberate and it is essentially always present.
• Vendor-run evaluations use vendor-chosen settings. Consensus-of-64 for yours, single-sample for theirs. Both numbers are real and the comparison is not.

There is no fix that survives contact with commercial incentives. The only durable answer is that you have to run your own evaluation on your own task.

the 10 million token claim#

Scout's context window is stated at 10M tokens, achieved through an interleaved attention scheme without positional embeddings in some layers, plus inference-time temperature scaling on attention. It was trained on far shorter sequences and generalizes upward.

Take this as an upper bound on what the architecture accepts, not on what it usefully processes. Independent long-context evaluations found substantial degradation well before that number. That is not unique to Llama 4 — it is true of every long-context claim — but 10M is a big enough number that the gap between accepted and useful is enormous.

what is actually good here#

The MoE architecture with 17B active parameters is a real efficiency story. Maverick's quality-per-active-parameter is strong, and active parameters are what determine inference cost. A model you can serve at 17B economics with much better quality than a 17B dense model is a genuinely useful thing to have.

Native multimodality — images in the base model rather than bolted on via an adapter — is also the right architecture and is where everyone is heading.

The license is still not open source. "Llama community license" has an MAU threshold and naming requirements. Call it open weights, which it is, and do not call it open source, which it is not.

the practical advice#

Build an eval harness with fifty examples from your actual domain. Run every candidate model against it. Store the results in your repo next to your tests.

It will take a day and it will make you immune to this entire genre of news.

the number#

DeepSeek's V3 paper stated a final training run cost of roughly $5.6 million in GPU-hours. That figure travelled around the world in about four days, usually stripped of every qualifier attached to it.

The qualifiers matter enormously:

• It is the cost of the final run only. It explicitly excludes research, failed runs, ablations, and data pipeline work — which in any frontier lab is the overwhelming majority of total spend.
• It excludes the capital cost of the cluster itself.
• It says nothing about R1's RL training, which came later and separately.

So "they trained a frontier model for $5.6M" is not what the paper says. It is what the internet decided the paper says.

why the market reacted anyway#

Because the directionally correct read survives the correction, and the market is a machine for reacting to directionally correct reads badly.

The directionally correct read: architectural efficiency gains are real and large. DeepSeek's mixture-of-experts design activates a small fraction of total parameters per token. Their multi-head latent attention cuts KV cache size substantially. Their FP8 training pipeline halves memory traffic against BF16. These are engineering wins, they are published, and they are reproducible.

If capability-per-FLOP is improving that fast, then the number of FLOPs you need to buy to reach a given capability is falling. That is the thesis that repriced today.

the counter-thesis#

Jevons. If compute gets cheaper per unit of capability, you do not buy less of it — you find more things to do with it. Reasoning models in particular consume enormous inference compute; a model that thinks for thirty seconds before answering is a very different demand curve than one that answers immediately. Efficiency gains in training get spent on inference.

Both theses are defensible. The honest answer is that nobody knows the shape of the demand curve, and a 17% single-day move in the largest company on earth is not a considered judgement about that. It is a positioning unwind.

for engineers specifically#

The useful lesson has nothing to do with stock prices. It is this: the performance-per-dollar frontier is moving fast enough that any architecture decision you make today assuming current inference costs will be wrong within a year, in your favor.

Do not build elaborate caching and routing infrastructure to shave token costs that are going to fall by an order of magnitude anyway. Build the thing. Measure it. Optimize when the bill actually hurts.

That advice would have been wrong in most previous computing eras. It is right now, and it will stop being right at some point, and watching for that moment is most of the job.

This is the most consequential open model release since Llama 2, and possibly since Llama 1.

what it is#

R1 is a chain-of-thought model in the same family as OpenAI's o1 — it produces a long internal reasoning trace before answering, and it spends more compute at inference time on harder problems. On the standard reasoning benchmarks (competition math, coding, graduate-level science questions) it lands in o1's neighborhood.

The training story is the part worth reading. The report describes R1-Zero, trained with reinforcement learning directly on the base model with no supervised fine-tuning stage at all, using rule-based rewards for verifiable domains — did the math answer match, did the code pass the tests. R1-Zero developed reasoning behavior spontaneously, including a documented moment where the model's trace reconsiders its own approach mid-solution.

R1-Zero's output was unreadable — language mixing, poor formatting — so R1 proper adds a cold-start supervised stage and a second RL pass to fix presentation. But the core finding stands: you can get reasoning to emerge from RL against verifiable rewards without a large human-labeled reasoning corpus.

why the license matters more than the benchmark#

MIT. Not a bespoke community license with a monthly-active-user carve-out. Not "research only." MIT, on the weights and the distilled variants.

That means anybody can fine-tune it, run it on their own hardware, ship it in a product, and never send a token to anyone's API. For regulated industries that have spent two years unable to get legal approval for a hosted frontier model, this is a door opening.

The distilled models are the practical story for most developers. The 32B distill runs on a single high-memory consumer GPU and is genuinely useful. The 7B and 14B variants run on a laptop.

the pricing#

DeepSeek's own API is priced at roughly a small fraction of comparable reasoning-model pricing from US labs. Whether that reflects genuinely lower serving costs, an architecture advantage from their mixture-of-experts design with a small number of active parameters, or a decision to buy market share, the effect on the market is the same.

what to actually watch#

Not the benchmark table. Watch these three things:

1. How fast the recipe gets reproduced. If RL-on-verifiable-rewards is as generalizable as the paper suggests, expect a wave of reasoning fine-tunes on other base models within weeks.
2. Whether the distills hold up outside benchmarks. Distilled reasoning traces can look right and be right for the wrong reasons.
3. The regulatory reaction. A capable open reasoning model trained outside US export-control jurisdiction is going to generate a policy conversation whether or not that conversation is technically coherent.

Download the weights. Whatever else happens, they exist now and cannot be un-released.