Qwen3,
explained.

Reasoning models like DeepSeek-R1 showed that letting a model generate a long chain-of-thought before answering dramatically improves hard problems — at the cost of many extra tokens. That created an awkward split: teams deployed a slow "reasoning" model for math and code, and a fast "chat" model for everything else, and had to route between them.

Qwen3 collapses that split. A single model supports a thinking mode (emit reasoning tokens, then answer) and a non-thinking mode (answer directly), and you choose per request. More than a toggle, it exposes a thinking budget — a cap on reasoning tokens — turning test-time compute into a continuous dial. One set of weights, tuned to be good at both, so you stop paying to host and route between two models.

The thinking budget is a cap on how many reasoning tokens the model may spend before it must commit to an answer. It makes the test-time-compute trade-off explicit and tunable: budget 0 is pure direct answering; a large budget lets the model reason at length. Two empirical facts about that curve make the budget powerful.

First, the accuracy gain from thinking saturates — the first reasoning tokens help a lot, later ones little, so past some point more thinking is wasted. Second, thinking helps far more on hard queries than easy ones: an easy question is usually answered correctly with no reasoning at all, leaving almost no headroom for thinking to add. Together these mean the value of a token of thinking depends heavily on which query it's spent on — and that's the opening for a smarter policy than "always" or "never".

If thinking mostly helps hard queries, the efficient policy is obvious: gate it on difficulty. Estimate how hard a query is, skip thinking when it's easy, and spend the budget when it's hard. That's how a controllable budget beats a fixed one — it moves compute to where the marginal token buys the most accuracy.

Concretely: on a batch of mixed queries, always-thinking pays the full reasoning cost on every request, including the majority that were easy and gained nothing. Gating on difficulty pays that cost only on the hard subset, keeping essentially the same accuracy for a fraction of the tokens. The saturation point also tells you how much to spend once you do think — enough to catch the steep part of the curve, not so much that you're past diminishing returns.

Model accuracy as a direct-answer baseline plus a saturating gain from thinking, where the headroom for that gain scales with query difficulty:

d = difficulty, t = thinking tokens, τ = saturation scale. At t=0, A=1−d (direct answer). The gain term is scaled by d, so easy queries (small d) have almost no headroom — thinking barely moves them — while hard queries (large d) gain a lot. The (1−e^−t/τ) factor saturates: early tokens help most.

Now the policy. Gate thinking on a difficulty threshold, and only spend the budget when the gate fires:

Easy queries cost 0 reasoning tokens; hard ones cost B. Against always-thinking (B on every query), the gate keeps the accuracy that mattered while spending a fraction of the tokens — the accuracy-per-token win. The runnable version below shows thinking helping hard queries far more, and adaptive budgeting undercutting always-think on tokens.

Qwen3 is a broad open release, and the hybrid mode is its distinctive idea:

Training such a model is a balancing act — teaching one set of weights to reason at length and to answer crisply without over-reasoning, so that turning the budget to zero yields a genuinely good direct answerer rather than a crippled reasoner. That the two modes coexist without either degrading is the practical achievement behind the clean user-facing dial.

Qwen3 reframed reasoning from a property of the model to a property of the request. The reasoning-model wave asked "is this a thinking model?"; Qwen3 answers "how much should this query think?" — the more useful question once you're paying per token in production. Treating test-time compute as an adjustable budget, rather than baked-in, is now a common design point, and other frontier models have adopted similar controllable-reasoning behavior.

The underlying principle is broader than any one model: reasoning tokens are compute, compute has diminishing returns, and returns depend on the problem — so the right amount of thinking is adaptive, not fixed. Qwen3 packaged that principle into a single deployable model with a knob a developer can actually turn. The frontier isn't only about models that can think harder; it's about models that know when to, and let you decide when they don't.