GO TO A SECTION

↑ ↓ to navigate · Enter to openExplore all sections →
FDEInterviews logo
arXiv preprint

Qwen3 Technical Report

One open model with a switch: think hard or answer fast, plus a token budget in between. The report shows where thinking pays (math, code) and where it doesn't (chat, long-context retrieval).

Breakdown by FDE Interviews · 12 min read · Updated

About the original · 2025
AUTHORS
Qwen Team
FROM
Alibaba (Qwen Team)
PUBLISHED
May 2025 · arXiv preprint
CITED BY
9,287Semantic Scholar · Oct 2026
IN THIS BREAKDOWN · 10 SECTIONS

You can read 18% of this breakdown.

01

The paper in one minute

Qwen3 is a family of eight open-weight models under Apache 2.0: dense models of 0.6B, 1.7B, 4B, 8B, 14B and 32B, and two mixture-of-experts models, 30B-A3B and 235B-A22B (235B total, 22B active per token, 128 experts with 8 active and no shared experts). All were pre-trained on 36 trillion tokens covering 119 languages and dialects, in three stages: about 30T general tokens at 4K length, about 5T reasoning-heavy tokens, then long-context data at 32K, extended to 128K at inference with YaRN.

The main product idea is one model with two modes. Adding /think or /no_think to a message (or a template flag) turns the reasoning block on or off; with thinking off the model emits an empty <think></think> and answers directly. A thinking budget stops reasoning after N tokens, inserts a fixed sentence telling the model to answer from what it has, and lets it finish.

The two flagships went through four post-training stages: a small long chain-of-thought cold start, reasoning RL with GRPO on 3,995 verifiable problems, a fusion stage that teaches both modes, and general RL across more than 20 task types. The six smaller models were distilled from them instead, first from teacher outputs and then by matching the teacher's token probabilities on the student's own samples.

The flagship scores 85.7 on AIME'24, 81.5 on AIME'25 and 70.7 on LiveCodeBench v5 with thinking, beating DeepSeek-R1 on 17 of 23 benchmarks. Without thinking it beats GPT-4o (November 2024) on 18 of 23.

THE IDEA, VISUALLY
ONE MODEL, TWO MODES, A BUDGET user: {query} /think <think> reasoning … </think> {response} default mode user: {query} /no_think <think></think> {response} same weights budget: at N thinking tokens, decoding stops the block and inserts "…give the solution based on the thinking directly now." </think> not trained for; the report says it emerged from mode fusion HOW EACH SIZE WAS POST-TRAINED 235B-A22B, 32B CoT cold start reasoning RL mode fusion general RL 0.6B, 1.7B, 4B, 8B, 14B, 30B-A3B distilled: teacher outputs (off-policy), then teacher logits (on-policy) 8B, on-policy distillation vs RL: 1,800 vs 17,920 GPU hours and AIME'24 74.4 vs 67.6 (Table 21) THE LINEUP dense 0.6B · 1.7B · 4B · 8B · 14B · 32B; MoE 30B-A3B, 235B-A22B 36T tokens, 119 languages; trained to 32K, 128K via YaRN x4 THINKING BUDGET, 235B (FIGURE 2, READ OFF THE PLOT) AIME'25 1K 4K 16K 32K off 24.7 81.5 GPQA Diamond 1K 4K 16K 32K off 62.9 71.9 thinking tokens allowed (log scale); dashed = non-thinking THINKING ON MINUS OFF, 235B (TABLES 11, 12) AIME'25 +56.8 LiveCodeBench v5 +35.4 GPQA Diamond +8.2 MMLU-Redux +3.5 BFCL v3 (tools) +2.8 IFEval +0.2 Arena-Hard -0.5 RULER long-context average, off vs on: 8B 89.1 vs 84.4 · 14B 94.6 vs 90.1 · 32B 93.7 vs 91.0 thinking helps math and code, not chat or retrieval
Thinking mode multiplies math and code scores and barely moves chat, instruction following or tool use, and it lowers long-context retrieval. The budget curves show most of the gain arrives between 4K and 16K thinking tokens.
Research notes: the problem, approach and results
+56.8

points on AIME'25 for Qwen3-235B-A22B with thinking on versus off (81.5 vs 24.7); Arena-Hard changes by -0.5

1,800 vs 17,920

GPU hours for on-policy distillation versus RL on the 8B model, with distillation scoring higher (AIME'24 74.4 vs 67.6)

36T

pre-training tokens across 119 languages and dialects, twice Qwen2.5's tokens and up from its 29 languages

THE PROBLEM

Teams ran two models: a fast chat model and a slow reasoning model, with routing between them. Small models trained with the full reasoning recipe are expensive to build, and nobody had a clean way to cap how long a reasoning model thinks.

THE IDEA

Train one model family (dense 0.6B to 32B, MoE 30B-A3B and 235B-A22B) with a chat template that switches thinking on or off per message, and a thinking budget that cuts reasoning at a set length. Build the flagships with four post-training stages and distill the small models from them.

THE RESULT

The flagship thinking model scores 85.7 on AIME'24 and 70.7 on LiveCodeBench v5; with thinking off, 40.1 and 35.3. Arena-Hard and IFEval are the same either way. Distilling the 8B from a teacher beat RL on it with a tenth of the GPU hours. On long-context retrieval, thinking mode scores lower at every size.

02

Why it matters to an FDE

The thinking switch turns a model-routing problem into a per-request setting, and this report has the data to set it.

Thinking pays on hard reasoning only. On the flagship, turning thinking on adds 56.8 points on AIME'25 and 35.4 on LiveCodeBench, but 0.2 on IFEval, 2.8 on BFCL tool calling and -0.5 on Arena-Hard. For a support chatbot or a tool-calling agent, thinking mostly adds latency and tokens. For SQL generation, debugging or calculation, it is the difference between usable and not.

Long-context retrieval gets worse with thinking. On RULER, thinking mode scores lower than non-thinking at every size (8B: 84.4 against 89.1). For RAG over long documents, the authors suspect the reasoning interferes with retrieval. Default to non-thinking there.

Budgets give a cost dial. The flagship's accuracy rises steeply between 4K and 16K thinking tokens on AIME and flattens after; on GPQA most of the gain is in by 8K. A product can cap thinking at the point where the next doubling stops paying.

Small models are distilled. The 4B and 8B models inherit both modes from the flagships. Distillation was ten times cheaper than RL on the 8B and scored higher, which is also a recipe for customers training their own small model from a larger one.

THE FULL BREAKDOWN

Understand the mechanism. Try it on a real problem.

Unlock this breakdown and 149 more papers.

Premium opens every paper in full, plus every answer, concept, course and guide on the site. One payment for six months of access.

6 months · One payment · No auto-renewal

Get Premium · ₹2,000 / $25
  • ◇1 architecture diagram
  • </>1 runnable code experiment
  • ▦2 results tables
  • ?5 interview questions with answers
  1. 03Key takeaways

    What each training stage did, the modes and budget in detail, distillation and three misreadings

    Free account
  2. 04How it works

    Architecture, the three pre-training stages, the four post-training stages and the distillation path

    Premium
  3. 05The numbers that matter

    Flagship results in both modes, the 32B ablation, distillation vs RL, budgets and long context

    Premium
  4. 06Try it yourself

    Recount the report's claims, rank tasks by what thinking adds, and choose a budget

    Premium
  5. 07Where it breaks

    Thinking hurts long context, reasoning traded for versatility, 128K via extrapolation, and unknowns

    Premium
  6. 08Using it on a deployment

    A per-request policy for thinking, budgets by task, and choosing a distilled size

    Premium
  7. 09Interview angles

    Five questions this report prepares you for, with answer hints

    Premium
Back to the paper library →