DeepSeek-V3.2: Pushing the Frontier of Open Large Language Models
Spend more on post-training than anyone thought sensible, synthesize 1,827 tool environments, and let the model learn to think inside a tool loop: V3.2 matches GPT-5, and its Speciale variant takes gold at IMO and IOI.
arXiv:2512.02556Where this sits
The Exp release proved that sparse attention could be attached to a trained backbone at parity; this report is the model that the experiment was for. It keeps the architecture and moves the frontier on the two axes the Exp report named as remaining bottlenecks: how much compute post-training deserves, and how open models generalize inside agent loops.
- Scales post-training RL past 10 percent of the pretraining compute budget, with the report attributing the reasoning gains directly to that expansion and to a stable RL protocol.
- Adds a cold-start stage that unifies reasoning and tool use within a single trajectory, so the model learns to think and call tools in one stream instead of switching modes.
- Synthesizes agentic training data at scale: 1,827 task-oriented environments and more than 85,000 complex prompts, built to be hard to solve and easy to verify.
- Matches GPT-5 on reasoning benchmarks in the report's comparisons and, with the length-constrained reward removed, produces V3.2-Speciale, which the report places on par with Gemini-3.0-Pro.
- Earns gold-medal-level results at IMO 2025, CMO 2025, IOI 2025, and the ICPC World Finals with the Speciale variant, without task-specific training for the competitions.
What it is
DeepSeek-V3.2 is the December 1, 2025 successor to the V3.2-Exp experiment and the flagship open release that closes the year. It keeps the DeepSeek Sparse Attention architecture from the Exp report - the lightning indexer and top-k selection that make long-context attention linear in the main path - and spends its effort on three things the Exp release did not: a reinforcement-learning protocol scaled past 10 percent of the pretraining compute, a large-scale synthesis pipeline that builds 1,827 verifiable tool environments and 85,000-plus prompts for agentic training, and a cold-start stage that teaches the model to interleave reasoning with tool calls in a single trajectory. The result is a model the report places level with GPT-5 on reasoning benchmarks, and a high-compute variant, V3.2-Speciale, that the report places with Gemini-3.0-Pro and that earns gold-medal results at IMO 2025, CMO 2025, IOI 2025, and the ICPC World Finals.
1Theory from first principles
The three deficiencies the report names
The report opens with a candid diagnosis of open models rather than a victory lap. First, most open models still use vanilla attention, which makes long sequences expensive and constrains both deployment and post-training. Second, their post-training compute is small relative to pretraining, which limits performance on hard tasks. Third, they lag on agentic generalization and instruction following inside tool loops, which is where real deployments happen. The architecture answer to the first deficiency already exists in the Exp report; this paper is about the other two, and its thesis is that the post-training budget is the lever that was left on the table.
Sparse attention, briefly
DSA is carried over unchanged: a small FP8 lightning indexer scores every preceding token for each query, a fine-grained selector keeps the top 2,048 key-value entries shared across query heads, and the main attention reads only those entries, turning its cost from quadratic into linear at a fixed k. The indexer remains quadratic but cheap, and the whole mechanism was trained into the model rather than applied at inference. What is new here is that the efficiency gain is no longer only a serving argument: it is what makes long-horizon RL rollouts affordable, because each rollout replays a long context through attention many times. The curriculum entry for V3.2-Exp covers the mechanism in detail; read this report for what the cheaper attention bought.
Post-training compute as the main variable
The report's central claim is empirical: reasoning performance kept improving as the RL budget grew, and the budget now exceeds 10 percent of the pretraining cost. That is a striking ratio, because post-training is usually a rounding error next to pretraining. Two engineering pieces make it stable. A robust RL protocol handles the usual failure modes of long-horizon training - reward noise, length drift, and collapse - and a length-constraint reward model keeps generations from inflating without improving. The constraint is also the experiment: when the authors remove it to build Speciale, performance rises further, which tells you the constrained model was trading tokens for trainability rather than hitting a capability wall.
Learning to think inside a tool loop
Agentic post-training has a cold-start problem: a model that has never called a tool cannot learn from tool feedback, and supervised tool-use data is expensive to write by hand. The pipeline solves it in two steps. First, cold start: reuse the V3 recipe to unify reasoning and tool use in single trajectories, so the model sees one stream that contains thinking, a call, the result, and more thinking. Second, synthesis at scale: an automatic environment-synthesis agent builds 1,827 task-oriented environments with their toolsets and verification, plus more than 85,000 prompts that are hard to solve but easy to check. RL then runs against those verifiable environments, which is why the gains generalize rather than memorizing a fixed tool set.
Where the compute goes
post_training_compute > 0.10 * pretraining_compute
Speciale: remove the length-constraint reward -> longer trajectories, higher scoresThe inequality is the report's headline resource statement: RL is not a finishing pass but a second training phase with a budget comparable in spirit to a tenth of pretraining. The second line is the controlled consequence: keeping the protocol and the data fixed and removing only the length penalty raises the ceiling. That isolates length regularization as a trainability tool, not a capability limit.
def agent_rollout(policy, env, question):
"""One trajectory interleaves reasoning and tool calls; the reward is the
environment's verifiable check on the final answer."""
context, steps = question, 0
while steps < MAX_STEPS:
out = policy.generate(context) # think + optionally call
if "tool_call" in out:
result = env.execute(out["tool_call"]) # verifiable environment
context += out["text"] + format(result)
else:
break # final answer emitted
steps += 1
return context, env.verify(context)
# The synthesis pipeline builds 1,827 such environments and 85k+ prompts;
# RL then optimizes the policy on the verifier's verdict.- The cold-start data shows the model this interleaving before RL ever runs, which is what makes the first rollouts useful instead of random.
- Verifiability is the constraint on synthesis: an environment is only usable if success can be checked mechanically, which is why tasks are generated hard to solve but easy to verify.
- The context keeps growing with each tool result, which is exactly the workload DSA's linear main attention was built to make affordable.
Results and the honest limits
The report compares V3.2 to GPT-5-class reasoning models at rough parity, with a cost advantage it emphasizes, and reports agentic numbers: SWE-bench Verified in the 72 to 74 range across frameworks and modes, Terminal Bench 2.0 at 46.4 using the Claude Code framework and 39.3 in non-thinking mode with Terminus, and tool-use scores of 63.8 (Airline), 81.1 (Retail), and 96.2 (Telecom) on the 2-bench categories. Speciale's gold medals at IMO, CMO, IOI, and ICPC are the headline. The limits section is unusually specific: world knowledge breadth still trails the leading closed model because total training FLOPs are lower; token efficiency is worse, since V3.2 needs longer generation trajectories to match output quality; and complex tasks remain behind the frontier. The context window is 128K, and some search-agent test cases exceed it, which required context management to score. Read this report for the RL budget argument and the environment synthesis recipe; read the Exp entry for the attention mechanism.
2Inside the paper
Problem the report sets out to solve
Open models were falling behind on complex tasks for three reasons the report names: expensive vanilla attention, too little post-training compute, and weak generalization in tool-use loops. V3.2 keeps the sparse attention from the Exp release and attacks the other two.
Key idea to look for while reading
Two budgets. The RL section is about spending more post-training compute than the field usually does, with a protocol stable enough to survive it. The agent section is about manufacturing verifiable environments at scale. Read the Speciale comparison carefully: it isolates the length-constraint reward by removing it and changing nothing else.
Evidence the report musters
Post-training compute above 10 percent of pretraining; 1,827 synthesized environments and over 85,000 prompts; parity with GPT-5 on reasoning benchmarks in the report's comparisons; Speciale on par with Gemini-3.0-Pro and gold-medal results at IMO 2025, CMO 2025, IOI 2025, and ICPC World Finals; SWE-bench Verified 72-74 across settings; Terminal Bench 2.0 46.4 and 39.3; tool-use scores 63.8 / 81.1 / 96.2 on the three 2-bench categories; 128K context.
Limits the report admits
World knowledge lags because of lower total training FLOPs; token efficiency is worse than the leading closed model, so equivalent quality costs more generated tokens; and complex tasks remain behind the frontier. The agent scores depend on context management because 128K is smaller than some test cases, and the framework used affects reported Terminal Bench numbers.
Practitioner takeaway
Treat post-training as a first-class compute budget, not a finishing touch: if reasoning keeps improving with RL compute, the constraint is protocol stability, not headroom. When you need agentic behavior, synthesize verifiable environments instead of collecting demonstrations, and let RL discover the loops. And keep a length penalty while training even if you remove it for your best model - it buys stability at a known price.
3Implementation check
0 of 5 questions answered
1.Which three deficiencies does the V3.2 report name for open models?
2.What is the report's headline resource claim about post-training?
3.How does the agentic synthesis pipeline make training data usable for RL?
4.What distinguishes V3.2-Speciale from V3.2 in the report's account?
5.Which limitation does the report state about V3.2's knowledge and efficiency?
4Build it yourself
Scale the rollout budget on a verifiable bandit
Starter2-3 hoursThree arms pass a check with hidden probabilities 0.5, 0.55, and 0.6; only sampling reveals the best one. Train a softmax policy with REINFORCE at budgets from 50 to 5000 episodes and measure how often the greedy arm is the true best, averaged over 40 seeds.
Milestones
- Fill train: seed the RNG, start the three logits at zero, and sample an arm from the softmax policy each episode.
- Take the arm's Bernoulli reward as the verifiable check, keep a running-mean baseline, and update the logits with the score-function gradient.
- Run budgets 50, 200, 1000, and 5000, and record the greedy arm for each seed.
- Average best-arm accuracy over 40 seeds and check the curve rises with the rollout budget.
- Compare the 5000-rollout accuracy with a uniform sampler that never trains and report the gap.
- Write down the budget ratio between the last and first runs and what the trend says about paying for more rollouts.
Success criteria
- Best-arm accuracy rises from about 0.55 at 50 rollouts to about 0.95 at 5000 in the printed 40-seed average.
- Every run keeps the logits finite and the full sweep finishes in under 5 seconds.
- The script prints all four budget rows in one run.
Stretch goals
- Replace the running-mean baseline with a per-arm baseline and compare the learning curve.
- Narrow the margins to 0.50, 0.51, and 0.52 and find the budget needed to reach 0.9 accuracy.
- Add a per-pull cost and re-run, checking whether the extra compute still pays for itself.