Nvidia's Nemotron-Cascade 2 wins math and coding gold medals with 3B active parameters — and its post-training recipe is now open-source

The prevailing assumption in AI development has been straightforward: larger models trained on more data produce better results. Nvidia's latest release directly challenges that size assumption — and the training recipe behind it may matter more to enterprise AI teams than the model itself. The open-weight model's Cascade RL post-training pipeline, detailed in Nvidia's technical report, offers a reproducible blueprint for enterprise teams building domain-specific reasoning systems without training from scratch.

Nemotron-Cascade 2 is an open-weight 30B Mixture-of-Experts (MoE) model that activates only 3B parameters at inference time. Despite this compact footprint, it achieved gold medal-level performance on three of the world's most demanding competitions: the 2025 International Mathematical Olympiad (IMO), the International Olympiad in Informatics (IOI), and the ICPC World Finals. It is the second open model to reach this tier, after DeepSeek-V3.2-Speciale — a model with 20 times more parameters.

Why post-training is becoming the real competitive advantage

Pre-training a large language model from scratch is enormously expensive — on the order of tens to possibly hundreds of millions of dollars for frontier models. Nemotron-Cascade 2 starts from the same base model as Nvidia's existing Nemotron-3-Nano — yet it outperforms that model on nearly every benchmark, and in many cases outperforms Nvidia's own Nemotron-3-Super, a model with four times the active parameters, according to Nvidia's technical report. The difference is entirely in the post-training recipe.

This is the strategic insight for enterprise teams: You don't necessarily need a bigger or more expensive base model. You may need a better training pipeline on top of the one you already have. Cascade RL and MOPD represent a specific, reproducible approach to that problem.

Cascade RL explained: sequential domain training that avoids catastrophic forgetting

Reinforcement learning (RL) has become the dominant technique for teaching LLMs to reason. The challenge is that training a model on multiple domains simultaneously — math, code, instruction-following, agentic tasks — often causes interference. Improving performance in one domain degrades it in another. This is the problem of catastrophic forgetting, a long-documented challenge in multi-task machine learning.

Cascade RL addresses this by training RL stages sequentially, one domain at a time, rather than mixing everything together. Nemotron-Cascade 2 follows a specific ordering: first instruction-following RL, then multi-domain RL (covering STEM questions, tool calling, and structured output), then on-policy distillation, then RLHF for human preference alignment, then long-context RL, then code RL, and finally software engineering RL.

Three properties make this approach practical, according to Nvidia’s technical report. First, domain-specific RL stages turn out to be resistant to catastrophic forgetting — training on code rarely degrades math performance, and in some cases actually improves it. Second, because each stage trains on a single domain, hyperparameters and the training curriculum can be tailored to that domain's specific characteristics, enabling better learning overall. Third, because responses within a single domain tend to be similar in length and verification cost, compute utilization is substantially more efficient than mixed-domain training.

The ordering itself is not fixed; it depends on the model's behavior. The Nemotron-Cascade 2 team found that instruction-following RL should come first (because it can conflict with human preference alignment, which can be recovered later), while code RL and software engineering RL work best as the final stages, according to the report.

For enterprise teams, the implication is straightforward: If you are applying RL to improve a model across multiple capabilities, training them sequentially with careful ordering may give you better results than trying to train everything at once.

MOPD: reusing your own training checkpoints as teachers

Even with careful sequential ordering, some performance drift is inevitable as the model passes through many RL stages. Nvidia's solution is Multi-Domain On-Policy Distillation (MOPD) — a technique inserted partway through the Cascade RL pipeline to rebalance capabilities.

The approach works as follows: As the model passes through different RL stages, some intermediate checkpoints will be the best-performing version for specific domains. The math checkpoint might be strongest after SFT; the instruction-following checkpoint might be strongest after IF-RL. MOPD selects the best intermediate checkpoint for each domain and uses it as a "teacher" to distill knowledge back into the student model.

Critically, these teachers are not external models. They come from the same training run, sharing the same tokenizer and architecture. This eliminates distribution mismatch problems that arise when distilling from a completely different model family.

According to Nvidia’s technical report, MOPD works at the token level rather than the sequence level, which makes it substantially more sample-efficient than RL with outcome-based rewards (GRPO etc). The Nvidia team reports that on the AIME 2025 math benchmark, MOPD recovered teacher-level performance within 30 optimization steps, while standard GRPO (Group Relative Policy Optimization) required more steps to achieve a lower score. On the ArenaHard benchmark for human preference alignment, MOPD reached 85.5 on hard prompts in 52 steps versus RLHF's 80.7 in 160 steps.

The benchmark picture: dominant in reasoning, honest about trade-offs

The results on reasoning-intensive benchmarks are striking. On LiveCodeBench v6, a coding benchmark with problems from competitive programming platforms, Nemotron-Cascade 2 scores 87.2 — surpassing Qwen3.5-35B-A3B (74.6), Qwen3.5-397B-A17B (83.6), and even Kimi-K2.5-1T (85.0). On HMMT February 2025, a rigorous math competition benchmark, it scores 94.6, neck-and-neck with models many times its size. On ArenaHard v2 for alignment quality, it reaches 83.5, well ahead of competitors in its class. With tool-integrated reasoning enabled, AIME 2025 performance climbs to 98.6. All benchmark scores are self-reported by Nvidia and have not been independently verified.

The technical report is also candid about weaknesses. The model underperforms Qwen3.5-35B-A3B on knowledge-intensive benchmarks like MMLU-Pro (79.8 vs. 85.3) and GPQA-Diamond (76.1 vs. 84.2), as well as on several agentic benchmarks like BFCL v4 and τ²-Bench. The authors explicitly note that stronger knowledge-intensive pre-training and agentic RL are needed in future work.

This honesty matters for practitioners. The model is optimized for deep reasoning and instruction-following — not general knowledge retrieval or complex multi-turn agent interactions. Teams should evaluate against their specific use case, not assume blanket superiority.

What enterprise AI teams can take from this recipe

Several design patterns from this work are directly applicable to enterprise post-training efforts. The sequential domain ordering in Cascade RL means teams can add new capabilities without rebuilding the entire pipeline — a critical property for organizations that need to iterate quickly. MOPD's approach of using intermediate checkpoints as domain-specific teachers eliminates the need for expensive external teacher models; teams can distill from their own best-performing snapshots.

The training setup is also notable: Cascade RL utilizes GRPO with strict on-policy training and no KL penalty via Nvidia's open-source Nemo-RL repository. For code RL, the pipeline used only 3,500 difficult, filtered problems.

The bigger picture: intelligence density as a design principle

Nemotron-Cascade 2 is part of a broader trend toward "intelligence density" — extracting maximum capability per active parameter.