ArXiv: 2512.20848

🎯 Pitch

A 31.6B-parameter model matches or beats GPT-OSS-20B and Qwen3-30B on agentic and reasoning tasks while running up to 3.3Γ— fasterβ€”and it maintains 99% of its accuracy even under aggressive FP8 quantization by selectively keeping just 6 attention layers and their preceding Mamba layers at full precision.

1. Executive Summary

This paper introduces Nemotron 3 Nano 30B-A3B, an open Mixture-of-Experts hybrid Mamba-Transformer language model that prioritizes the inference-throughput-to-accuracy frontier. The model β€” evaluated against Qwen3-30B-A3B-Thinking-2507 and GPT-OSS-20B on benchmarks spanning reasoning (AIME25, GPQA), agentic tasks (SWE-Bench, TauBench V2), long context (RULER at up to 1M tokens), and chat β€” uses a granular MoE architecture activating only 3.2B of its 31.6B parameters per forward pass and achieves up to 3.3Γ— higher inference throughput than similarly-sized open models while being more accurate on popular benchmarks. The post-training pipeline combines supervised fine-tuning on diverse agentic and reasoning traces, multi-environment reinforcement learning from verifiable rewards trained on all environments simultaneously, and reinforcement learning from human feedback with a generative reward model and group-relative length control, yielding best-in-class agentic and reasoning performance. A key finding is that the FP8 quantized version retains approximately 99% median accuracy recovery relative to BF16 through a selective quantization strategy that keeps the 6 self-attention layers and their preceding 6 Mamba layers in BF16, establishing that throughput gains from aggressive KV cache quantization only become practical when the most sensitive architectural components are preserved at higher precision.

2. Context and Motivation

The Core Problem: LLMs Are Too Expensive to Run

The central tension this paper addresses is practical and urgent: modern large language models are remarkably capable but prohibitively expensive to serve at scale. The inference cost of a model β€” measured in tokens per second per GPU, latency, and memory footprint β€” directly determines whether it can be deployed in real-world applications. A model that is 3Γ— slower than a competitor of equal quality is simply non-viable for latency-sensitive applications like conversational agents, interactive coding assistants, or real-time tool use. Yet the dominant trend in the field has been toward ever-larger models, with parameter counts growing from billions to hundreds of billions, driving inference costs higher.

This creates a specific architectural gap that Nemotron 3 Nano sets out to fill: can we design a model that matches or exceeds the accuracy of the best similarly-sized open models while delivering dramatically higher inference throughput? The paper frames this explicitly as pushing the inference-throughput-to-accuracy frontier (Figure 1). This is not merely an engineering optimization problem β€” it requires a fundamental rethinking of the model architecture itself to be compute-efficient at inference time while remaining competitive during training.

The problem matters for several concrete reasons that the paper touches on throughout:

  • Agentic deployment requires fast, multi-step reasoning. Autonomous software engineering agents (SWE-Bench), conversational tool-use assistants (TauBench V2), and terminal-based problem solvers (Terminal Bench) all generate long trajectories with dozens of sequential model calls. Each call adds latency; slow models make these workflows impractical regardless of raw accuracy. The paper's emphasis on up to 3.3Γ— higher throughput for 8K input / 16K output scenarios (Section 1, Figure 1) directly targets this use case.

  • Long-context inference amplifies the throughput problem. Supporting context lengths of 1M tokens (Section 1, Section 2.5) is essential for real-world agentic tasks that involve large codebases, multi-document synthesis, or extended conversation histories. But long-context inference is quadratically expensive for pure-attention Transformers due to the self-attention computation. Architectural innovations that mitigate this cost (hybrid Mamba-Transformer, MoE sparsity) become existential requirements rather than optional optimizations when context windows extend to a million tokens.

  • Open-weight models democratize capability but face a throughput penalty. Unlike proprietary models served behind API endpoints with dedicated, optimized infrastructure, open-weight models must run on diverse, often constrained hardware. A 3.3Γ— throughput advantage means the difference between a model that can run interactively on a single H200 GPU and one that requires expensive multi-GPU setups β€” a direct contributor to accessibility for researchers, startups, and resource-constrained deployments. The paper's release of weights, data, code, and recipes (Section 1) is explicitly motivated by this democratization goal.

Prior Approaches Fall Short Along Three Dimensions

The paper positions itself against a specific landscape of prior work, identifying shortcomings in three primary areas:

1. Dense Transformer Models: Compute-Wasteful by Design

The dominant architecture in open-source LLMs β€” exemplified by models like GPT-OSS-20B and, to a lesser extent, Qwen3 variants β€” is the dense Transformer with Grouped-Query Attention (GQA). These models activate all parameters on every forward pass, regardless of token complexity. This is compute-wasteful for two reasons:

  • Not every token needs the full model. A simple token like "the" or a punctuation mark receives the same compute budget as a token in the middle of a complex mathematical derivation. Mixture-of-Experts architectures address this by activating only a subset of specialized parameters per token, but prior to Nemotron 3 Nano, no open MoE model had been combined with a Mamba-Transformer hybrid architecture to simultaneously optimize for training efficiency (through Mamba's linear-complexity sequence modeling) and inference sparsity (through MoE's conditional computation).

  • Self-attention scales poorly with sequence length. Pure-attention Transformers incur O(LΒ²) computational cost for a sequence of length L. The Mamba-2 state space model (Dao & Gu, 2024) reduces this to approximately O(L) for sequence mixing, but prior hybrid architectures (Nemotron-H, Nemotron 2 Nano) had not combined Mamba-2 with MoE layers. The paper explicitly builds on these predecessors (Section 2.1) by "replacing the standard FFN layers with sparse Mixture-of-Experts layers" β€” a direct response to the throughput limitation of dense models.

2. Existing MoE Models Don't Maximize the Throughput-Accuracy Frontier

MoE architectures are not new. DeepSeek-V3 (DeepSeek-AI, 2025b) and Qwen3-30B-A3B (Yang et al., 2025a) both use MoE layers to scale parameters sparsely. But the paper identifies specific limitations in how these models translate sparsity into real-world throughput:

  • Qwen3-30B-A3B-Thinking-2507 serves as the primary comparator throughout the paper. While it has a similar parameter profile (30B total, 3B active), it achieves only 1.0Γ— relative throughput compared to Nemotron 3 Nano's 3.3Γ— on the 8K input / 16K output benchmark (Figure 1). This dramatic gap β€” 3.3Γ— faster despite similar active parameter counts β€” suggests that raw MoE sparsity alone does not determine throughput; the specific MoE granularity (128 routable experts, 6 activated), the hybrid Mamba-Transformer layer pattern that reduces attention overhead, and the model's compatibility with FP8 quantization all interact to determine final throughput. The paper does not attribute the gap to any single factor but demonstrates it empirically, leaving the architectural ablation as implicit.

  • GPT-OSS-20B-A4B achieves slightly better relative throughput (1.5Γ— to Qwen3's 1.0Γ—) but at the cost of significantly degraded performance on key benchmarks. Figure 1 shows it trailing on AIME25 (22.0 vs. Nemotron's 49.0), IFBench (51.0 vs. 71.5), and long-context RULER (not available at 1M tokens). The paper positions GPT-OSS as the "fast but less accurate" baseline, while Nemotron 3 Nano aims to dominate both axes simultaneously.

The fundamental issue is that training MoE models is harder than training dense models β€” the routing dynamics must converge to specialized experts, load balancing must prevent expert collapse, and the benefits of sparsity must survive the quantization needed for deployment throughput. Prior open MoE models have achieved some, but not all, of these goals. Nemotron 3 Nano is positioned as a synthesis that achieves all simultaneously.

3. Post-Training Pipelines Are Fragmented and Environment-Specific

Beyond architecture, the paper identifies a structural problem in how LLMs are post-trained for agentic and reasoning capabilities. The typical pipeline β€” Supervised Fine-Tuning (SFT) followed by optional Reinforcement Learning (RL) β€” suffers from a specific pathology that Section 3.2 addresses head-on:

"single environment training often results in un-recoverable degradation of other benchmarks"

This observation is critical and reflects a widespread frustration in the field. When a model is fine-tuned with RL on math reasoning problems alone (e.g., DAPO or SkyWorks math), its performance on coding, instruction following, or agentic tool use often collapses β€” a phenomenon the paper calls "un-recoverable degradation." The model over-specializes to the RL environment's reward signal, losing the general capabilities acquired during SFT. Prior work attempted to mitigate this through careful data mixing during SFT or by training separate expert models for each domain, but this fragments deployment (you need different model checkpoints for different tasks) and doesn't scale to the growing diversity of agentic environments.

The paper's solution β€” multi-environment reinforcement learning from verifiable rewards (RLVR) with simultaneous training on all environments β€” is positioned as a direct response to this degradation problem. By training on competition math, competition coding, STEM question answering, structured JSON outputs, instruction following, long-context QA, and multi-step agentic tool use environments concurrently, the model avoids catastrophic forgetting of any single capability. The curriculum sampling strategy (Section 3.2.2, Figure 6) that shifts from high-pass-rate to low-pass-rate samples over training further refines this by ensuring the model doesn't overfit to easy examples in any single domain.

Prior post-training approaches β€” including the Nemotron 2 Nano pipeline that preceded this work β€” either trained on fewer environments (making the degradation problem more manageable) or trained sequentially (fine-tuning on math, then code, then agentic tasks), which the paper implicitly argues is inferior to the simultaneous approach. The fact that Nemotron 3 Nano is the team's "first effort to scale up reinforcement learning in the post-training stage" (Section 3, opening paragraph) underscores that this simultaneous multi-environment RL is a novel contribution, not an incremental improvement.

4. No Prior Work Has Combined All These Pieces Into One Open Model

The paper's positioning becomes clearest when viewed holistically: no prior open model combines (1) a granular MoE architecture with 128 experts and 6 activated, (2) a Mamba-2/Transformer hybrid that reduces attention overhead, (3) multi-environment simultaneous RLVR, (4) RLHF with a generative reward model and group-relative length control to prevent reasoning verbosity bloat, (5) FP8 quantization with selective mixed-precision to achieve deployment-viable throughput, and (6) full open release of weights, data, code, and recipes.

Any individual piece existed in prior work β€” Mamba-2 hybrids (Jamba, Nemotron-H), MoE scaling (DeepSeek-V3, Qwen3), RLVR (DeepSeek-R1), RLHF with GenRM (HelpSteer3) β€” but the integration is what the paper argues produces the "best-in-class performance" across reasoning and agentic and chat and long-context benchmarks simultaneously, without the throughput penalties that typically accompany such breadth.

How This Paper Positions Itself

The paper frames its contribution not as a single algorithmic breakthrough but as a systems-level integration that advances the Pareto frontier of accuracy-vs-throughput for open-weight models. This is evident in the structure: pretraining (§2) focuses on architecture and data scale (25 trillion tokens, 3 trillion new over Nemotron 2), post-training (§3) describes the SFT→RLVR→RLHF pipeline with specific innovations at each stage, and quantization (§4) demonstrates that the architecture is robust to FP8 compression — a practical requirement for deployment that is often treated as an afterthought but is central to the paper's throughput claims.

The paper also positions itself within a broader trend toward agentic AI β€” models that don't just answer questions but take actions, call tools, execute code, and operate over extended time horizons. The emphasis on tool-integrated reasoning traces (Β§3.1.2), terminal-use trajectories, SWE-Bench software engineering, and multi-turn conversational tool use reflects a belief that the next frontier for LLM evaluation and deployment is not pure reasoning benchmarks but interactive, verifiable agentic tasks. The throughput advantages of the architecture are particularly valuable in this setting because agentic workflows generate many sequential model calls.

A subtle but important positioning move: the paper does not claim superiority over all models on all benchmarks. In Table 3, GPT-OSS-20B leads on AIME25 (no tools: 91.70 vs. 89.06), Terminal Bench (hard subset: 10.00 vs. 8.51), and a few other narrow categories. Qwen3 leads on AA-LCR (59.00 vs. 35.85) and MMLU-ProX (77.60 vs. 59.50). The paper is transparent about these gaps, which strengthens the credibility of its central claim: on balance, across the full suite of benchmarks, Nemotron 3 Nano achieves better or on-par accuracy while being significantly faster. This is a Pareto-dominance claim, not a universal-superiority claim, and the paper's evaluation breadth (general knowledge, reasoning with and without tools, agentic tasks, instruction following, long context, multilingual) gives it weight.

Finally, the paper positions its openness as a contribution in itself. The release of pretraining datasets (Nemotron-CC-v2.1: 2.5T new tokens, Nemotron-CC-Code-v1: 428B tokens, Nemotron-Pretraining-Code-v2, Nemotron-Pretraining-Specialized-v1), SFT and RL datasets (Nemotron-SFT-Data, Nemotron-RL-Data), the GenRM used for RLHF (Qwen-3-Nemotron-235B-A22B-GenRM), and the training infrastructure (NeMo Gym, NeMo RL) is unusually comprehensive. This positions the paper not just as a capability demonstration but as a reproducible recipe for building efficient, agentic models β€” a direct response to the field's reproducibility challenges.

3. Technical Approach

3.1 Reader Orientation

The system described in this paper is a complete pipeline for building and serving a highly efficient, open-weight language model β€” from scraping and curating 25 trillion tokens of pretraining data through architecting a sparse hybrid Mamba-Transformer to post-training with simultaneous multi-environment reinforcement learning and finally quantizing to FP8 for deployment. The core problem it solves is the tension between model capability and inference cost: modern LLMs are powerful but too slow and memory-hungry to serve interactively at scale, especially for agentic workflows that chain together dozens of sequential model calls. The "shape" of the solution is a model that activates only 10% of its parameters per forward pass (3.2B out of 31.6B) through a granular MoE architecture, mixes Mamba-2 state-space layers for efficient long-context sequence processing with attention layers for retrieval, and survives aggressive FP8 quantization through a selective mixed-precision strategy that preserves accuracy by keeping the most sensitive layers at higher precision.

3.2 Big-Picture Architecture (Diagram in Words)

The Nemotron 3 Nano system has five major components, arranged in a sequential pipeline:

  1. Pretraining Data Engine (Β§2.2, Β§2.3) β€” A multi-source data curation pipeline that ingests Common Crawl snapshots, GitHub repositories, Wikipedia, academic text, and synthetic data from LLM-based generation, produces quality-filtered and rephrased tokens organized into 15 categories, and mixes them across two phases (diversity-heavy, then quality-heavy) for a total of 25 trillion tokens.

  2. Hybrid Mamba-Transformer MoE Architecture (Β§2.1) β€” The 52-layer model backbone that interleaves Mamba-2 state-space layers with sparse Mixture-of-Experts layers (128 routable experts, 6 activated per token, plus 2 shared experts) and a small number of Grouped-Query Attention layers (6 out of 52 layers). This architecture gives linear-complexity sequence processing from Mamba, sparse conditional computation from MoE, and targeted retrieval capability from attention.

  3. Supervised Fine-Tuning Pipeline (Β§3.1) β€” A diverse training stage on agentic, reasoning, tool-use, long-context, and safety data (over 18M samples) that imbues the base model with reasoning budget control, reasoning on/off control, and tool-integrated reasoning capabilities, using a custom chat template with XML-style tool tags.

  4. Multi-Environment Reinforcement Learning from Verifiable Rewards (Β§3.2) β€” A unified RL stage that trains on competition math, competition coding, STEM question answering, structured JSON outputs, instruction following, long-context QA, and agentic tool use environments simultaneously, using GRPO with a curriculum that shifts from easy to hard samples over time to prevent catastrophic forgetting of any single capability.

  5. RLHF with Generative Reward Model and Length Control (Β§3.3) β€” A final alignment stage using a large GenRM (Qwen3-235B-A22B) trained via GRPO, combined with a Group Relative Length Control mechanism that penalizes verbosity within each response group to prevent reasoning bloat on non-reasoning-heavy prompts.

  6. Selective FP8 Quantization (Β§4) β€” A post-training quantization step that converts most model weights and activations to FP8 while keeping the 6 self-attention layers and their preceding 6 Mamba layers in BF16, preserving ~99% median accuracy while enabling the throughput gains that the architecture's sparsity alone cannot deliver under memory constraints.

Information flows sequentially: raw web/text data β†’ pretraining corpus (25T tokens) β†’ base model (Warmup-Stable-Decay, 25T tokens) β†’ SFT (on reasoning, agentic, chat traces) β†’ RLVR (simultaneous multi-environment) β†’ RLHF (GenRM + length control) β†’ FP8 quantization β†’ deployment. The RLVR and RLHF stages both operate on the SFT checkpoint, with RLVR applied immediately after SFT and a second RLVR stage optionally applied after RLHF.

3.3 Roadmap for the Deep Dive

  • First, the architectural backbone (Section 2.1): the Mamba-2/attention/MoE hybrid, because every downstream design choice β€” from training stability to quantization sensitivity β€” flows from this architecture. Understanding the layer pattern, the MoE routing mechanism, and the load-balancing strategy is essential before discussing training.
  • Second, the pretraining data and curriculum (Β§2.2, Β§2.3, Β§2.4): the 25-trillion-token corpus, its 15 categories, the two-phase curriculum, and the Warmup-Stable-Decay schedule, because the base model capabilities set the ceiling for all downstream post-training.
  • Third, the SFT stage (Β§3.1): the chat template, reasoning control mechanisms, and diverse data mixture, because SFT establishes the behavioral scaffold that RLVR and RLHF then refine.
  • Fourth, the multi-environment RLVR stage (Β§3.2): the environments, the curriculum sampling strategy, the infrastructure (NeMo Gym + NeMo RL), and the GRPO algorithm configuration, because this is the paper's primary post-training innovation and the mechanism by which the model achieves best-in-class agentic and reasoning performance without catastrophic forgetting.
  • Fifth, the RLHF stage (Β§3.3): the GenRM training, the circular comparison strategy, and the Group Relative Length Control mechanism, because this addresses a subtle but practical problem (reasoning verbosity bloat on simple prompts) that prior RLHF approaches miss.
  • Sixth, the FP8 quantization strategy (Β§4): the selective mixed-precision approach and its accuracy-throughput tradeoffs, because deployment throughput is the paper's central claim and quantization is what makes the architectural throughput advantages real under memory constraints.

3.4 Detailed, Sentence-Based Technical Breakdown

This is primarily a systems paper whose core idea is that simultaneously optimizing architecture (MoE + Mamba-2 hybrid), training data scale and quality (25T tokens, 3T new), post-training methodology (multi-environment RLVR), and deployment quantization (selective FP8) produces an open model that jointly dominates the accuracy-throughput Pareto frontier for its size class.

Hybrid Mamba-Transformer MoE Architecture

The architecture is defined by Table 1 and illustrated in Figure 2. The model is 52 layers deep with a model dimension (d_model) of 2688. It uses Grouped-Query Attention with 32 query heads and 2 key-value heads, each producing a head dimension of 128. The Mamba-2 layers use a state dimension of 128, 8 Mamba groups, 64 Mamba heads, and a Mamba head dimension of 64. The MoE layers use an expert hidden dimension of 1856 with 128 total routable experts, of which 6 are activated per token, plus 2 shared experts that are always active.

Layer pattern (Figure 2). The 52 layers are not uniform. The paper specifies a repeating pattern, visible in Figure 2:

  • A block of 5 layers, repeated 5 times, consisting of alternating Mamba-2 and MoE layers in the sequence: MoE β†’ Mamba-2 β†’ MoE β†’ Mamba-2 β†’ MoE.
  • A separate block of 3 layers with the pattern: Attention β†’ Mamba-2 β†’ MoE (repeated 3 times, making 9 layers).
  • A block of 1 layer: Mamba-2 β†’ Attention β†’ MoE (3 layers).
  • A final block of 4 layers: Mamba-2 β†’ MoE β†’ Mamba-2 β†’ MoE, but with 4 MoE layers and 3 Mamba-2 layers, making 7 layers.

This complex interleaving produces a total of 6 self-attention layers out of 52 β€” approximately 11.5% of the layers use quadratic-complexity self-attention. The remaining sequence mixing is handled by Mamba-2 state-space layers, which have approximately linear complexity in sequence length. The MoE layers (which replace standard FFN layers) appear frequently β€” essentially wherever a dense feed-forward layer would appear in a standard Transformer β€” providing sparse conditional computation throughout the model.

MoE routing. Each MoE layer uses a standard learned MLP router with sigmoid gating. For a given input token representation $x$, the router produces a vector of 128 scores (one per routable expert), applies a sigmoid activation to produce gating values between 0 and 1, and selects the top-6 experts by score. The output of the MoE layer is the weighted sum of the 6 selected experts' outputs, plus the output from the 2 always-active shared experts (following DeepSeekMoE's architecture; Dai et al., 2024):

MoE(x)=βˆ‘i∈TopK(sigmoid(Wrx),6)giβ‹…Ei(x)+βˆ‘j=12Ejshared(x)\text{MoE}(x) = \sum_{i \in \text{TopK}(\text{sigmoid}(W_r x), 6)} g_i \cdot E_i(x) + \sum_{j=1}^{2} E^{\text{shared}}_j(x)

where $W_r$ is the router weight matrix, $g_i = \text{sigmoid}(W_r x)_i$ is the gating value for expert $i$, $E_i$ and $E^{\text{shared}}_j$ are the routable and shared expert functions respectively, and $\text{TopK}(\cdot, 6)$ selects the indices of the 6 largest gating values.

What it computes: for each token, the router first computes an affinity score for each of the 128 experts via a learned linear projection followed by sigmoid, then takes the top 6 scores, retrieves the corresponding expert FFNs, runs the token through each, and combines their outputs weighted by the normalized gating values. The 2 shared experts are always applied regardless of routing decisions, providing a baseline transformation that captures common patterns (e.g., linguistic regularities) while the routed experts specialize.

Why this form: the granular MoE design (many small experts, few activated) provides two benefits over coarse MoE (few large experts). First, it enables finer-grained specialization: an expert can become highly specialized to a narrow type of computation (e.g., mathematical reasoning, code syntax, specific languages) without wasting capacity on unrelated tokens. Second, it improves load balancing: with 128 experts and only 6 activated, the probability of any single expert becoming a bottleneck is reduced compared to, say, 8 experts with 2 activated. The shared experts (DeepSeekMoE innovation) address the "token dumping" problem where common tokens (prepositions, punctuation) would otherwise consume expert capacity without benefiting from specialization β€” these bland tokens can be handled by the shared experts, leaving routed experts free to specialize.

Load balancing. The paper uses DeepSeek's aux-loss-free load balancing strategy (Wang et al., 2024) combined with a small standard load balancing loss:

Lload=Laux-free+10βˆ’4β‹…Lstandard\mathcal{L}_{\text{load}} = \mathcal{L}_{\text{aux-free}} + 10^{-4} \cdot \mathcal{L}_{\text{standard}}

where $\mathcal{L}_{\text{aux-free}}$ uses an expert-level bias term that dynamically adjusts to balance the load without adding a gradient-based auxiliary loss, and $\mathcal{L}_{\text{standard}}$ is the traditional load balancing loss (Lepikhin et al., 2020) that penalizes uneven token distribution across experts. The update rate for the expert bias in the aux-free method is $10^{-3}$.

What it computes: the aux-free method maintains a per-expert bias $b_i$ for each expert $i$. After each training step, if expert $i$ is overloaded (receiving too many tokens relative to capacity), its bias is decreased, making the router less likely to select it; if underloaded, its bias is increased. The standard load balancing loss computes the squared coefficient of variation of the token counts across experts, encouraging uniform usage. The total loss combines both with a small coefficient ($10^{-4}$) on the standard loss to provide a soft gradient signal, relying primarily on the bias mechanism to handle load balancing without introducing gradient noise.

Why this form: traditional load balancing losses (like the one in Lepikhin et al., 2020) add a term to the training objective that directly penalizes uneven routing. This creates a tension between load balancing (which wants all experts used equally) and task performance (which wants the best expert for each token, even if that creates imbalance). The aux-free approach decouples these: load balancing is achieved through the bias mechanism, which doesn't produce gradients through the router, so the router's task-performance gradients are not corrupted by balancing pressure. The small standard loss term ($10^{-4}$) is retained as a safety measure but is not the primary balancing mechanism. This is important for training stability: strong load balancing gradients can prevent experts from specializing by forcing all of them to handle a uniform token distribution, reducing the effective capacity of the MoE layer.

Normalization and other architectural details. The model uses RMSNorm for normalization, squared ReLU activation for the MoE expert FFNs, and no positional embeddings, dropout, or bias on linear layers. The embedding and projection (output) weights are untied. These choices collectively follow modern architectural best practices: RMSNorm is faster than LayerNorm, squared ReLU provides stronger gradient signal than regular ReLU for deep networks, removing bias terms reduces parameter count without empirical degradation, and untying embeddings allows the input and output representations to specialize differently.

Pretraining Data: Curation, Generation, and Mixture

The pretraining corpus spans 15 categories (Section 2.3, Figure 3) and totals 25 trillion tokens. The categories are:

  • Web crawl data, subdivided into five quality buckets following the Nemotron-CC taxonomy (Su et al., 2025): crawl-medium, crawl-medium-high, syn-crawl-medium-high (synthetic rephrasing of medium-high quality), crawl-high, and syn-crawl-high. These buckets together constitute the largest fraction of the mixture.
  • Math: 6.4% (Phase 1), 12.5% (Phase 2).
  • Wikipedia: 0.6% (Phase 1), 1.3% (Phase 2).
  • Code: 14.0% in both phases, including both raw GitHub code and synthetically generated/transpiled code.
  • Nemotron-CC-Code: 1.3% (Phase 1 only) β€” code extracted from Common Crawl web pages via the Lynx + LLM pipeline.
  • Academic text: 4.1% (Phase 1), 2.0% (Phase 2).
  • Crawl++: 2.9% (Phase 1 only), consisting of OpenWebText, BigScience, and Reddit datasets.
  • Multilingual data: 5.0% (both phases), covering 19 languages.
  • SFT-style synthetic data, subdivided into code-sft, stem-sft, and general-sft categories. The stem-sft category is notably large: 11.1% in Phase 1, 22.3% in Phase 2.

Nemotron-CC-Code-v1 (427.92B tokens). This dataset extracts code from Common Crawl web pages. The pipeline works as follows (Section 2.2.1): First, a fast pattern-matching code classifier identifies pages likely to contain code. Raw HTML is rendered using Lynx, a text-based browser that preserves code layout, indentation, and inline technical elements without the HTML overhead. The rendered text is processed by an LLM-based cleaning stage using the Phi-4 model, which removes boilerplate (navigation bars, ads, cookie banners) while strictly retaining code snippets, configuration blocks, API references, and mathematical expressions. A lightweight code-quality relevance classifier then filters out non-technical pages that survived the initial pattern matching. The final output standardizes equations to LaTeX and preserves code blocks with structural fidelity.

Nemotron-Pretraining-Code-v2. This dataset refreshes the GitHub code corpus. The curation pipeline (same as Nemotron 2 Nano; NVIDIA, 2025d) applies multi-stage filtering, deduplication, and quality filters. Beyond raw source code, the paper introduces several synthetic data augmentation strategies:

  1. Q&A generation: using Qwen3 32B, generate question-and-answer pairs using the new source-code data as seeds, similar to the instruction-tuning data generation approach from Nemotron-H (NVIDIA, 2025e).

  2. Dialogue generation: generate student-teacher (Python only) and code-review (Python/C++) style dialogues grounded in code snippets and full source files, simulating the kind of multi-turn interactions that downstream users would have.

  3. Code rephrasing (following Fujii et al., 2025): using Qwen3 32B, rephrase all raw Python source code using Style-Guided Code Rewriting (SGCR) and Self-Contained Optimization Rewriting (SCOR) prompts, plus a custom prompt with similar intent. SGCR changes the coding style (variable naming, code organization) while preserving functionality; SCOR makes code more modular and self-documenting. Post-processing checks for syntax errors and runs the Pylint linter to ensure the rephrased code is correct and higher-quality.

  4. Code transpilation (a novel extension of the rephrasing concept): using Qwen3 32B, transpile all Python source files to C++. The key insight is that transpilation produces C++ tokens that train the model on cross-language translation patterns, improving downstream C++ code-generation accuracy. This is applied to the entire Python subset of the source-code corpus.

Nemotron-CC-v2.1 (2.5 trillion new tokens). This dataset extends the Nemotron-CC web crawl data pipeline with three new Common Crawl snapshots (CC-MAIN-2025-18, 2025-21, 2025-26), plus two novel data expansion strategies:

  1. Expanded rephrasing: previously, only the High-Quality subset was rephrased. In v2.1, the Medium-High-Quality data from 110 Common Crawl snapshots (covering 2013–2025) is rephrased using five prompts (Su et al., 2025) via Qwen3-30B-A3B, producing 2.1 trillion new tokens. The five prompts vary in style β€” some preserve the original text closely, others produce more abstractive rewrites β€” creating diverse paraphrases of the same information.

  2. Multilingual translation to English: documents from 9 languages (Chinese, French, German, Italian, Japanese, Polish, Portuguese, Russian, Spanish) in three recent Common Crawl snapshots are translated to English using Qwen3-30B-A3B. The Nemotron-CC quality classifiers are then applied to retain only High-Quality and Medium-High-Quality documents. Additionally, four of the five rephrasing prompts are applied to the high-quality translated data. An after-the-fact LLM-based quality filter removed approximately 10.6% of tokens (uninformative translated documents like daily conversations and advertisements that had received spuriously high scores from the original quality classifiers), which slightly improved benchmark accuracy in internal ablations.

Nemotron-Pretraining-Specialized-v1. This dataset comprises several specialized synthetic datasets:

  • Synthetic Wikipedia Data: Wikipedia articles are revised using Qwen3-30B-A3B-Instruct-2507 to improve clarity and formatting. Disambiguation/redirect pages are discarded; References, See also, Notes, and External Links sections are removed; irrelevant content like uncleaned HTML elements is stripped.

  • Synthetic Math Textbook Data: Nemotron-CC-Math documents are classified by educational level (grade school through graduate) based on mathematical concepts and complexity. Documents at the undergraduate level and above are developed into textbook-style sections with definitions, illustrative examples, and structured exposition.

  • Synthetic Scientific Coding Data: Two types of documents are generated from STEM-related seed documents: (1) code-embedded articles that explore and implement a graduate- or research-level scientific or mathematical algorithm in Python, and (2) computational coding problems decomposed into 5–15 logically ordered substeps, each solved by an individual function. The decomposition ensures the dataset teaches structured problem-solving, not just monolithic code generation.

  • InfiniByte Cross-Breeding: a novel approach that creates new programming problems by combining concepts from different domains. Starting from competitive coding problems in OpenCodeReasoning (Ahmad et al., 2025b), concepts are systematically injected from mathematics (OpenMathReasoning), physics (Physics Big), chemistry (IChO), and other sciences. Multiple candidates are generated per combination, and an LLM-as-critic rubric selects the best based on clarity, difficulty, and adherence to the cross-breeding strategy. Two strategies are used: (1) obfuscation β€” surface-level changes that don't materially alter the problem (common in competitive programming), and (2) complication β€” genuinely increasing complexity by requiring reasoning across multiple concepts. Solutions are generated using Qwen3-235B-A22B-Thinking-2507. The pipeline is implemented in NeMo Data Designer, which handles concept grounding via Jinja templating, structured output enforcement, feedback loops, data validation, and automated retries.

  • Reasoning Question-Answer (RQA) dataset: designed to demonstrate advanced scientific reasoning and reinforce correlations between advanced topics. A four-step pipeline: (1) Filter Essential-Web STEM documents to undergraduate/graduate level with advanced reasoning depth, high technical correctness, and specific Bloom cognitive processes (Analyze, Evaluate, Create) and knowledge domains (Conceptual, Procedural, Metacognitive) β€” yielding ~14 million documents. (2) Apply hierarchically stratified sampling using the Free Decimal Correspondence (FDC) numerical topic code to ensure maximum diversity for a given volume; ultimately use the first 4.5 million. Documents over 4096 characters are chunked to random contiguous segments under 4096 characters. (3) Present each seed document to Qwen3-235B-A22B-Thinking-2507 to generate a difficult graduate-level scientific reasoning question (filtered if they require more than 8192 reasoning tokens to produce). (4) Present each question to the same model (without the original seed passage) to generate a reasoning trace and answer, filtered to remove model-specific idiosyncrasies and limited to 8192 characters. This two-step design ensures the teacher model's reasoning is maximally engaged both in question generation and answering. The final RQA dataset has 4.3 million demonstrations (~31.7 billion tokens).

  • Diverse QA (DQA) dataset: a companion to RQA built from the same stratified STEM seed documents (first 9 million), using the DQA generation procedure from Nemotron-CC: concatenate a text chunk with short-form question-answer pairs generated by Qwen3-30B-A3B, producing ~8 billion tokens.

  • SFT-style data included in pretraining: refreshed SFT datasets for code, math, and STEM, using DeepSeek-R1 as the teacher model for responses. This collection encompasses prompts from NuminaMath, OrcaMathWordProblems, MathInstruct, MetaMathQA, TACO, APPs, OpenCoder-Stage2, and OpenCodeReasoning, plus additional math and code samples from AceReason-Nemotron-1.1 (Liu et al., 2025a).

Data mixture and curriculum (Figure 3). The pretraining is divided into two phases:

  • Phase 1 (94% of training, ~23.5T tokens): emphasizes diversity. The largest components are syn-crawl-high (20.4%), code (14.0%), syn-crawl-medium-high (11.7%), stem-sft (11.1%), crawl-medium (6.8%), crawl-high (6.5%), math (6.4%), and crawl-medium-high (5.7%). The diversity-heavy mixture ensures the model is exposed to a wide range of text types, writing styles, and knowledge domains before being fine-tuned on quality.

  • Phase 2 (6% of training, ~1.5T tokens): emphasizes quality. Many lower-quality components are dropped: crawl-medium, crawl++ (OpenWebText/BigScience/Reddit), and nemotron-cc-code are removed entirely. The syn-crawl-medium-high proportion drops from 11.7% to 5.0%. High-quality components increase: stem-sft doubles to 22.3%, math doubles to 12.5%, wiki more than doubles to 1.3%, code-sft doubles to 6.7%. This phase acts as a "quality annealing" step β€” the model has already learned broad capabilities from diverse data, and the final 1.5T tokens refine those capabilities on the most reliable, highest-quality sources.

The transition point (94%) is a specific design choice: the authors found that too much high-quality data early in training reduces model generalization by overfitting to narrow text distributions, while too little prevents the model from reaching peak benchmark performance. The 94/6 split is an empirical optimum identified through internal ablations, though the paper does not report the specific ablation results.

Pretraining Hyperparameters and Schedule

Warmup-Stable-Decay schedule. The model is trained using the Warmup-Stable-Decay (WSD) learning rate schedule (Hu et al., 2024) for 25 trillion tokens:

  • Warmup: 8.4 billion tokens, LR linearly increased to $10^{-3}$.
  • Stable: 20 trillion tokens (80% of total), LR held constant at $10^{-3}$.
  • Decay: 5 trillion tokens (remaining 20%), LR linearly decreased to $10^{-5}$.

The WSD schedule is a specific choice over the standard cosine decay schedule. In cosine decay, the learning rate continuously decreases throughout training, meaning that later tokens are effectively "less important" than earlier ones β€” the model's learning rate is lowest precisely when it's seeing the most refined data. The WSD schedule keeps the learning rate high through the diversity phase (Phase 1), allowing the model to continue learning aggressively from diverse data, then decays during the quality-focused Phase 2, ensuring that the final high-quality tokens are integrated stably without overshooting. The stable phase length (80% of total tokens) is unusually long compared to standard schedules, reflecting the paper's commitment to data diversity.

Optimizer. AdamW (Loshchilov & Hutter, 2017) with weight decay 0.1, $\beta_1 = 0.9$, $\beta_2 = 0.95$. The weight decay of 0.1 is relatively high, indicating that the model is aggressively regularized to prevent overfitting on the massive but potentially noisy pretraining corpus. The $\beta_2 = 0.95$ (rather than the default 0.999) reduces the momentum of the second moment estimates, which is beneficial for training with the WSD schedule because it allows the optimizer to adapt more quickly when the learning rate decays β€” a slow-moving $\beta_2$ would keep applying large effective learning rates even after the scheduled decay begins.

Batch size and sequence length. Batch size 3072, sequence length 8192, yielding approximately 25 million tokens per batch ($3072 \times 8192 = 25,165,824$). For the MoE layers, the aux-loss-free load balancing strategy (Wang et al., 2024) uses an update rate of $10^{-3}$ for the expert bias, combined with a standard load balancing loss coefficient of $10^{-4}$.

Long-Context Extension

After the main pretraining, a long-context phase (LC-Phase) uses continuous pretraining (CPT) to extend the context length to 1M tokens (Section 2.5). The LC-Phase uses a constant learning rate of $10^{-5}$ and global batch size 48. The parallelism configuration reflects the computational challenge of long-context training: 8-way context parallelism (splitting the sequence across devices), 8-way tensor parallelism, 8-way expert parallelism, and 4-way pipeline parallelism, all on H100 GPUs.

Data blend for LC-Phase. The LC-Phase data blend consists of:

  • 20% long-context document QA data (reused from Nemotron Nano 2 but scaled 3Γ— larger).
  • 1% synthetic retrieval-focused data (maximum sequence length 256K tokens) to specifically improve RULER-style retrieval tasks.
  • 79% downscaled Phase 2 data.

Sequence length mixture during CPT. The paper initially tried training only on 524,288 (512K) token sequences, but found that short-context benchmark scores (MMLU-Pro, Code) were impacted to a small extent. The solution: mix 512K and 4K sequences in the CPT data. The 4K sequences maintain the model's short-context capabilities, while the 512K sequences extend the context window. This is a specific finding: context extension via CPT can cause retroactive forgetting of short-context capabilities if the training distribution shifts entirely to long sequences. The mixture prevents this by keeping the model anchored to normal-length inputs.

Total tokens: 121 billion for the LC-Phase.

Supervised Fine-Tuning

The SFT stage is trained on over 18 million total samples across 13 categories (Figure 5), using a batch size of 64 with sequence packing to a maximum sequence length of 256K tokens. Training runs for 13,000 steps with a learning rate of $5 \times 10^{-5}$ and 800 steps of warmup. A sequence-level MoE load balancing regularizer with coefficient $10^{-4}$ is applied.

Chat template and reasoning control (Section 3.1.1, Figure 4). The chat template implements two forms of reasoning control:

  1. Reasoning on/off control: 10% of SFT samples have their reasoning traces stripped, training the model to respond without explicit chain-of-thought when appropriate. The model can thus serve in both "thinking" and "non-thinking" modes depending on the system prompt.

  2. Reasoning budget control: 3% of SFT traces have their reasoning randomly truncated to different lengths before continuing with the original post-reasoning response. This teaches the model to produce coherent answers even when its reasoning allocation is cut short, enabling deployment-time budget constraints.

For multi-step tool use, the template preserves reasoning tokens from the current turn while dropping reasoning from previous turns when a new user message is introduced (Figure 4). For example: in Turn 1, the user asks a question, the assistant reasons and calls a tool, the tool returns results, and the assistant reasons again before responding. All of Turn 1's reasoning is preserved within that turn. But when Turn 2 begins with a new user message, Turn 1's reasoning is dropped from context, freeing context space for the new interaction. Tool calls use XML-style special tags (following GLM-4.5 and Qwen3-Coder observations) to reduce character escaping compared to JSON-style tool call formats.

Data mixture (Figure 5). The SFT blend is dominated by Chat (28.6%), Code (20.7%), Science (12.8%), Math (9.9%), and Multilingual (7.4%). Smaller but notable components include Math with Tools (4.9%), Software Engineering (SWE, 3.0%), GenSelect (3.0%), Conversational Agent (2.0%), Formal Proofs (2.0%), Long Context (2.0%), and Terminal Use (1.5%). The data is dynamically sampled: smaller datasets are trained over for many epochs, larger datasets for only a few, based on the approximate amount of data empirically required to achieve optimal single-task performance.

Key data generation details.

  • Competition Math: responses are refreshed with GPT-OSS 120B, compared to Nemotron Nano 2. Tool-integrated reasoning traces using Python tools are created with GPT-OSS 120B as teacher.

  • Terminal Use: tasks are based on Terminal Bench and adapted from competitive coding, competitive math, and long-context datasets. SWE-Smith (Yang et al., 2025b) provides real-world software engineering tasks. Action trajectories are generated using Qwen3-Coder-480B-A35B-Instruct and Kimi-K2-Instruct-0905 via the Terminus-1 and Terminus-2 agents.

  • Software Engineering: training data is distilled from OpenHands, SWE-Agent, and Mini-SWE-Agent trajectories on SWE-Gym (Pan et al., 2025) and R2E-Gym (Jain et al., 2025) datasets, using Qwen3-Coder-480B-A35B-Instruct as teacher.

  • Safety: unsafe prompts are paired with refusal wrappers; safe prompts are rejected with over-refusal templates to create preference pairs for downstream RLHF.

Data filtering. A unified filtering pipeline is applied across all domains. Malformed examples (e.g., missing tool definitions when tool calls are present) are discarded. Reasoning traces exhibiting pathological repetition β€” detected via n-gram repetition within a sliding window or across the entire trajectory β€” are aggressively filtered, as this is a strong indicator of low-quality synthetic reasoning. Finally, keyword- and regex-based filters remove trajectories where the teacher model implicitly aligns with specific political entities or promotes nationalistic narratives (patterns like "our nation/party [...], our values").

Why SFT needs to be this diverse: a common pitfall in SFT is creating a model that excels at a narrow set of benchmarks but generalizes poorly. By training on chat, code, math, science, agentic tool use, terminal environments, formal proofs, long context, and multilingual data simultaneously, the SFT stage establishes a broad behavioral foundation. The subsequent RLVR stage then sharpens specific capabilities without collapsing this breadth β€” a direct response to the "un-recoverable degradation" problem when RL is applied to models with narrow SFT foundations.

Multi-Environment RLVR

This is the paper's primary post-training innovation. The core idea: train on all RL environments simultaneously rather than sequentially, using a curriculum that dynamically shifts from easy to hard samples over time.

Environments (Section 3.2.1). Seven environment categories are trained on concurrently:

  1. Competition Math: 17K tasks from DAPO (Yu et al., 2025) + 104K tasks from SkyWorks math (He et al., 2025). Reward is binary correctness on the final answer.

  2. Competition Coding: 22K tasks from OpenCodeReasoning (Ahmad et al., 2025b). Unit tests are capped at 50 per task to bound verification time. Reward is fraction of unit tests passed.

  3. STEM Question Answering: 135K multiple-choice tasks generated from reference documents. Reward is binary multiple-choice accuracy.

  4. Structured Outputs: 9K tasks requiring the model to produce JSON conforming to a specified schema. A document and schema are given; the model must summarize the document according to the schema. Reward is exact schema adherence (no partial credit), with no reward for semantic content β€” this trains pure syntactic reliability independent of content quality.

  5. Instruction Following (two environments):

    • IFEval-style: 46K tasks with constraints from the IFBench training set (Pyatkin et al., 2025). Reward is verifiable constraint satisfaction.
    • Multi-turn complex: 3K tasks inspired by Multi-Challenge (Deshpande et al., 2025), using LLM-as-judge to verify subtle multi-turn instruction following.

  6. Long Context: 12K QA tasks requiring reference to at least 5 documents, with total input limited to 32K tokens. Generated by Qwen3-235B-A22B-Thinking-2507; corrected by Qwen3-235B-A22B-Instruct-2507 as LLM judge.

  7. Agentic Tool Use (two environments):

    • Workplace Assistant: a multi-step verifiable tool-calling environment with 5 databases, 26 tools, and 690 tasks (adapted from Styles et al., 2024). Correctness is verified by executing the tool calls and comparing the resulting database state to ground truth.
    • Multi-turn Conversational Agent: ~1K tasks in complex banking scenarios (unblocking credit cards, resolving account disputes). Correctness is verified by database state comparison.

Curriculum sampling (Section 3.2.2, Figure 6, Figure 7). The key mechanism that makes simultaneous multi-environment training work:

  • Initial profiling: the SFT checkpoint is evaluated on all tasks. Tasks where it already achieves 100% pass rate are removed (they provide no learning signal). The remaining tasks are assigned a difficulty based on the SFT checkpoint's pass rate: low pass rate = harder.

  • Gaussian target distribution: for each domain, the target pass rate distribution is modeled as a Gaussian. The mean of this Gaussian shifts linearly from high pass rate (easier problems) early in training to low pass rate (harder problems) later. At each training step, samples are drawn from near the current target mean, creating a smooth curriculum that avoids both trivial and impossible examples.

  • Fixed domain ratios: each batch maintains a fixed ratio of samples from each domain (e.g., always 20% math, 15% coding, 10% long-context, etc.), ensuring no domain is neglected. Within each domain, the specific samples are selected by the Gaussian curriculum.

  • Re-profiling and iterating: when training progress plateaus, tasks are re-profiled using the current best RL checkpoint, and a new curriculum is constructed. This prevents the curriculum from becoming stale β€” as the model improves, the definition of "hard" shifts.

Figure 7 demonstrates the curriculum's importance: with random sampling (no curriculum), the model biases toward easier tasks, preventing it from effectively learning harder ones and causing a degradation pattern (performance on some benchmarks actually decreases during training). With curriculum sampling, stable improvement is observed across GPQA, LiveCodeBench, AIME 2025, and IFBench Prompt simultaneously.

Surpassing SFT with RLVR (Figure 8). The paper compares RLVR training progress against two SFT baselines:

  • SFT1: the initial RLVR starting point (~3 epochs of SFT).
  • SFT2: a heavily fine-tuned checkpoint trained to full convergence (~5 epochs).

Across GPQA, LiveCodeBench, AIME 2025, and IFBench Prompt, RLVR consistently exceeds or matches SFT2 within 250 training steps. This is a significant finding: RLVR with a modest number of steps can surpass even a heavily over-trained SFT baseline that was trained to convergence, demonstrating that the RL signal provides learning that SFT alone cannot achieve.

Algorithm: GRPO with masked importance sampling (Section 3.2.5). The RL algorithm is synchronous Group Relative Policy Optimization (GRPO) with masked importance sampling to correct for training-inference distribution mismatch (the policy that generates rollouts may differ slightly from the policy being trained, and importance sampling corrects for this). The configuration:

  • 128 prompts per step (batch size).
  • 16 generations per prompt (rollouts).
  • Total batch size: $128 \times 16 = 2048$.
  • Updates are on-policy (the policy is updated immediately after the batch, no replay buffer).
  • MoE router weights are frozen during RLVR to prevent routing collapse (the router already learned good expert assignments during pretraining; RL gradients could destabilize these).
  • Aux-loss-free load balancing with continued expert bias updates (Wang et al., 2024) is maintained even with frozen router weights.
  • Maximum generation length: 49K tokens.
  • Overlong filtering (Yu et al., 2025) is applied: if a generation exceeds the maximum length, it is discarded. The paper reports this boosts performance on reasoning-intensive benchmarks because incomplete generations (truncated mid-reasoning) would otherwise provide noisy or negative training signals.

Why freeze MoE router weights? During RL training, the reward signal can cause the policy to shift its token distribution, which in turn changes which experts are activated for each token. This creates a feedback loop: the router adapts to the new distribution, which changes the model's capabilities, which changes the reward signal, causing further distribution shift. Freezing the router stabilizes this loop, ensuring that the expert assignments remain consistent with the pretrained model's understanding of token-expert affinities. The aux-free load balancing with bias updates continues to function even with frozen router weights because the bias operates on the router's output without modifying the router's parameters.

Infrastructure (Section 3.2.4). The RL training infrastructure uses NeMo Gym and NeMo RL integrated with vLLM for inference and Megatron-Core for training. NeMo Gym's abstraction is built on three server types:

  • Agent servers: implement the rollout kernel of an RL environment (e.g., executing tool calls in Workplace Assistant).
  • Model servers: wrap vLLM to provide prompt-response APIs, preserving token and inference log-prob data required for RL.
  • Resource servers: provide verification APIs that compute rewards from a given rollout (e.g., running unit tests for coding tasks).

NeMo RL orchestrates the training loop, using Megatron-Core for distributed model training and routing all rollouts through NeMo Gym and vLLM. This architecture allows different environments to be developed and deployed independently while sharing a common RL training backbone.

Reinforcement Learning from Human Feedback with GenRM

The RLHF stage addresses a different problem than RLVR: aligning the model with human preferences on tasks where no verifiable reward function exists (e.g., general chat, creative writing, instruction following on open-ended prompts). The approach has two parts: training a generative reward model (GenRM), then using it as the reward signal for RLHF with a length control mechanism.

GenRM training (Section 3.3.1). The GenRM is built from Qwen3-235B-A22B-Thinking-2507 (Yang et al., 2025a) trained via GRPO. For each input, the GenRM receives: conversation history, a new user request, and two candidate assistant responses. The model first reasons through the strengths and weaknesses of both responses, then produces individual helpfulness scores (1–5 scale, higher = more helpful) for each response and a ranking score (1–6 scale, where 1 = response 1 far superior, 6 = response 2 far superior). The reward for GenRM training is:

R=βˆ’C1Iformatβˆ’βˆ£Ph1βˆ’Gh1βˆ£βˆ’βˆ£Ph2βˆ’Gh2βˆ£βˆ’C2∣Prβˆ’Gr∣R = -C_1 I_{\text{format}} - |P_{h1} - G_{h1}| - |P_{h2} - G_{h2}| - C_2 |P_r - G_r|

where $P_{h1}, P_{h2}$ are the predicted helpfulness scores for responses 1 and 2, $G_{h1}, G_{h2}$ are the ground-truth helpfulness scores, $P_r$ is the predicted ranking, $G_r$ is the ground-truth ranking, $I_{\text{format}}$ indicates whether the prediction violates the format requirement, and $C_1 = 10, C_2 = 1$ are hyperparameters controlling the relative weight of format violations and ranking accuracy versus helpfulness score accuracy.

What it computes: the reward is a negative sum of errors. The first term $-C_1 I_{\text{format}}$ heavily penalizes (by -10) any format violation, ensuring the GenRM learns to produce properly structured outputs. The second and third terms $-|P_{h1} - G_{h1}| - |P_{h2} - G_{h2}|$ penalize deviations from the ground-truth helpfulness scores (L1 loss on a 1–5 scale). The fourth term $-C_2 |P_r - G_r|$ penalizes ranking errors (L1 loss on a 1–6 scale) with weight 1. Since all terms are non-positive, the maximum reward is 0 (perfect prediction on all metrics with correct formatting).

Why this form: the reward decomposes the GenRM's task into three evaluable sub-tasks (formatting, helpfulness calibration, relative ranking). The heavy weight on formatting ($C_1=10$) reflects that a reward model that produces unparseable outputs is useless regardless of its judgment quality β€” it's the gating condition for the downstream RLHF loop. The helpfulness score terms use L1 loss (rather than L2) because the helpfulness scale is coarse (1–5) and outliers are bounded; L1 is more robust to the natural ambiguity in human helpfulness judgments. The ranking term uses $C_2=1$ because ranking is a higher-level judgment that's harder than individual helpfulness assessment β€” the model must compare, not just evaluate. A higher weight would incentivize the model to focus on ranking at the expense of calibration.

Training data: HelpSteer3 (Wang et al., 2025b), a commercially-friendly subset of lmarena-ai/arena-human-preference-140k (Chiang et al., 2024), and a synthetic safety blend (Appendix D). Each sample is augmented by swapping the positions of the two responses to prevent positional bias. GenRM training uses 128 prompts per batch, 8 generations per prompt, and one gradient step on the full batch.

GenRM evaluation (Figure 10). Performance on RM-Bench (Liu et al., 2024), JudgeBench (Tan et al., 2024), and an internal validation set steadily improves over 800 training steps. RM-Bench accuracy reaches approximately 0.878, JudgeBench approximately 0.74, and the internal validation set approximately 0.645, all showing clear improvement from scaling up RL training.

RLHF with GenRM (Section 3.3.2). With the GenRM trained, RLHF proceeds using the same prompts as GenRM training. Configuration: 128 prompts per batch, 16 responses per prompt. The challenge: naively comparing all pairs of 16 responses would require $\binom{16}{2} = 120$ GenRM calls per prompt, which is prohibitively expensive at scale. The solution is a circular comparison strategy: each response $r_i$ is compared only with its successor: $(r_1, r_2), (r_2, r_3), \ldots, (r_{15}, r_{16}), (r_{16}, r_1)$. This yields exactly 16 comparisons per prompt, reducing computational cost from $O(N^2)$ to $O(N)$ while still connecting all responses in a comparison graph. Each response is judged twice in different positions to mitigate positional bias.

For each pairwise comparison $(r_i, r_j)$, the GenRM produces scores $s_i, s_j \in [1, 5]$ and ranking $s_r \in [1, 6]$. A tiebreaker mechanism handles equal helpfulness scores:

si=si+(3.5βˆ’sr)s_i = s_i + (3.5 - s_r) sj=sj+(srβˆ’3.5)s_j = s_j + (s_r - 3.5)

What it computes: if $s_r = 3.5$ (perfect tie in ranking), the tiebreaker adds 0 to both scores. If $s_r < 3.5$ (response $i$ is ranked higher), $s_i$ gets a positive bonus and $s_j$ gets a negative penalty. If $s_r > 3.5$ (response $j$ ranked higher), the reverse occurs. The tiebreaker effectively uses the ranking signal to break ties in helpfulness, converting an ordinal judgment (which response is better) into a cardinal adjustment to the scalar scores.

Why this form: the ranking score $s_r$ is anchored at 3.5 (midpoint of 1–6), making the tiebreaker zero-sum between the two responses. This preserves the total reward scale β€” no reward inflation or deflation occurs from tiebreaking. Without a tiebreaker, the RL signal would be flat whenever $s_i = s_j$, providing no guidance even when one response is genuinely preferred. The tiebreaker recovers a gradient signal from the ranking information.

The base reward $R^{\text{(base)}}_i$ for response $r_i$ is the average of its two scores from two matches (each response participates in two circular comparisons).

Group Relative Length Control. A practical problem observed during RLHF: response length rapidly increases as training progresses, not from reward hacking (the GenRM is not fooled by verbosity) but because the model learns to spend more inference-time compute on "reasoning" even when prompts don't require it. This mirrors observations from DeepSeek-R1 (DeepSeek-AI, 2025a) where models allocate more thinking tokens to achieve higher rewards, but for RLHF prompts (general chat, creative writing), this reasoning is largely redundant β€” the GenRM judges only the final answer, not the reasoning trace.

The Group Relative Length Control mechanism addresses this with two components:

Length-Normalized Reward Adjustment:

wi(think)=1βˆ’β„“i(think)βˆ’β„“min(think)β„“max(think)βˆ’β„“min(think)w^{\text{(think)}}_i = 1 - \frac{\ell^{\text{(think)}}_i - \ell^{\text{(think)}}_{\text{min}}}{\ell^{\text{(think)}}_{\text{max}} - \ell^{\text{(think)}}_{\text{min}}}

where $\ell^{\text{(think)}}_i$ is the length of the reasoning component of response $r_i$, $\ell^{\text{(think)}}_{\text{min}} = \min_j \ell^{\text{(think)}}_j$ is the shortest reasoning length in the group, and $\ell^{\text{(think)}}_{\text{max}} = \max_j \ell^{\text{(think)}}_j$ is the longest. The weight $w^{\text{(think)}}_i$ ranges from 1 (for the shortest response) to 0 (for the longest).

What it computes: for each response, compute a normalized length score where the shortest reasoning gets weight 1 and the longest gets weight 0. The intuition: within a group of responses to the same prompt, shorter reasoning is preferable if quality is held constant, so assign higher bonuses to shorter responses.

The weight is then centered to be zero-mean across the group:

w~i(think)=wi(think)βˆ’1Nβˆ‘j=1Nwj(think)\tilde{w}^{\text{(think)}}_i = w^{\text{(think)}}_i - \frac{1}{N} \sum_{j=1}^{N} w^{\text{(think)}}_j

The same procedure is applied to answer component lengths to obtain $\tilde{w}^{\text{(answer)}}_i$. The final reward for response $r_i$ is:

Ri=Ri(base)+Ξ»(think)w~i(think)+Ξ»(answer)w~i(answer)R_i = R^{\text{(base)}}_i + \lambda^{\text{(think)}} \tilde{w}^{\text{(think)}}_i + \lambda^{\text{(answer)}} \tilde{w}^{\text{(answer)}}_i

where $\lambda^{\text{(think)}} = 0.5$ and $\lambda^{\text{(answer)}} = 0.5$.

Why this form: the centering step (subtracting the group mean) ensures the length adjustment is zero-sum within the group β€” the total reward across all responses is unchanged, so the RL algorithm doesn't experience reward scale drift. Without centering, the bonus would be strictly positive for all responses (since $w \geq 0$), creating reward inflation that would require re-tuning hyperparameters. The zero-mean property also means that the length bonus only differentiates between responses in the same group: a response with average-length reasoning gets approximately zero bonus, while shorter-than-average responses get positive bonuses and longer-than-average get negative penalties. The coefficients $\lambda = 0.5$ are moderate β€” strong enough to create a meaningful gradient toward conciseness, but not so strong that they overpower the GenRM's quality signal.

Quality-Gated Conciseness Bonus. To prevent the model from learning to produce short but low-quality responses, additional bonuses are awarded only to the shortest responses that achieve top-tier quality:

Rk←Rk+Ξ²(think)β‹…1[Rk(base)β‰₯Ο„p]R_k \leftarrow R_k + \beta^{\text{(think)}} \cdot \mathbb{1}\left[R^{\text{(base)}}_k \geq \tau_p\right]

for the response $r_k$ with minimum reasoning length, and similarly for the response with minimum answer length, where $\beta^{\text{(think)}} = 0.5$, $\beta^{\text{(answer)}} = 0.5$, and $\tau_p$ is the 80th percentile threshold of base reward scores within the group. The indicator function $\mathbb{1}[\cdot]$ is 1 only if the condition holds.

What it computes: find the response with the shortest reasoning. If that response's base reward (from GenRM) is at or above the 80th percentile of the group's base rewards, give it an extra +0.5 bonus. Same for the shortest answer. If the shortest response is low-quality, no bonus. This ensures the length incentive only applies when conciseness doesn't come at the cost of quality.

Why this form: without the quality gate, the length bonus would incentivize the model to produce the shortest possible responses regardless of quality β€” a degenerate "just say nothing" strategy. The percentile threshold ($\tau_{80}$) ensures that only responses in the top 20% of the group by quality get the conciseness bonus, creating a joint optimization: be good and be brief. The bonus magnitude (0.5) is moderate relative to the base reward scale (GenRM scores are in the 1–5 range, so a 0.5 bonus is approximately a 10–50% increase depending on the base score), making conciseness a tiebreaker rather than the primary objective.

The paper reports that verbosity reduces 30% during training without sacrificing accuracy, validating that the mechanism successfully trades off reasoning length for cleanliness without degrading output quality.

Selective FP8 Quantization

After post-training in BF16, the model undergoes post-training quantization (PTQ) to FP8 using ModelOpt and Megatron-LM. The goal: achieve the throughput gains shown in Figure 1 while preserving accuracy. The key insight is selective quantization β€” not all layers are equally sensitive to precision reduction.

Calibration dataset. The calibration uses 1K samples from the post-training reasoning SFT dataset (not generic text like CNN/DailyMail). An ablation showed that SFT-based calibration data yields slightly better accuracy recovery than CNN/DailyMail, likely because the SFT data distribution better matches the downstream deployment distribution. An attempt to use on-policy generations from the BF16 model as calibration data showed no additional benefit.

Sensitivity analysis (Figure 11). Three factors are explored: attention layer quantization (BF16 or FP8), Mamba layer quantization (FP8 or mixed BF16/FP8), and KV cache quantization (BF16 or FP8). The key finding: KV cache FP8 quantization significantly improves throughput by enabling larger batch sizes (the KV cache is the primary memory bottleneck for long-sequence inference), but causes accuracy degradation unless the most sensitive layers are preserved.

The selective quantization configuration that is used for the final model: the 6 self-attention layers (out of 52) are kept in BF16, along with the 6 Mamba layers that immediately precede them (which feed into the attention layers). All other Mamba layers, all MoE layers, and the KV cache are quantized to FP8. The 1D convolution (Conv1D) within all Mamba layers is kept in BF16 regardless of the Mamba layer's overall precision.

Why attention layers are most sensitive: self-attention computes $\text{softmax}(QK^T / \sqrt{d})V$, where the softmax is highly sensitive to small perturbations in the attention scores. FP8 quantization introduces larger quantization errors than BF16, which can cause the softmax to become either too peaky (overconfident attention to a single token) or too flat (losing the ability to focus). The Mamba-2 state-space layers use a different mathematical structure (structured state space duality, Dao & Gu, 2024) that is empirically more robust to FP8 quantization, hence they can be quantized without significant degradation.

Why the preceding Mamba layers also need BF16: the Mamba layers that feed into the attention layers provide the input to the attention computation. Quantization error in these layers propagates through the attention mechanism and is amplified by the softmax nonlinearity. Keeping them in BF16 prevents this error cascade.

Accuracy recovery (Table 4, Figure 11). The selective FP8 model achieves approximately 99% median accuracy recovery relative to BF16 across all benchmarks. Specific regressions are minimal: AIME25 (no tools) drops from 89.06 to 87.71 (βˆ’1.35%), SciCode drops from 33.28 to 31.88 (βˆ’1.40%), while some benchmarks show slight improvement due to the regularization effect of quantization (e.g., IFBench improves from 71.51 to 72.19). The throughput improvement is significant: the selective FP8 configuration achieves roughly 250% of BF16 throughput in Figure 11 (the red dot labeled "Nemotron 3 Nano 30B-A3B FP8"), compared to other configurations that either have lower throughput or lower accuracy recovery.

Ablation insights (Figure 11). The ablation study systematically varies quantization configurations:

  • Quantizing attention to FP8 (even with BF16 KV cache) significantly reduces accuracy recovery (to ~96–97%), demonstrating attention layer sensitivity.
  • Quantizing KV cache to FP8 dramatically improves throughput (comparing points with KV-BF16 vs. KV-FP8 at the same attention/Mamba quantization setting), but the throughput gain can only be realized if the attention layers are left in BF16 β€” otherwise the accuracy penalty is too severe.
  • The "selective quant" configuration (attn-BF16, KV-FP8, with the 6 preceding Mamba layers also in BF16) achieves the sweet spot: near-perfect accuracy recovery (~99% median) with the large throughput gain from FP8 KV cache and FP8 MoE/Mamba layers.

This selective strategy is a specific empirical finding, not an obvious design choice: the paper had to discover through systematic ablation which specific layers were sensitive enough to warrant mixed precision. The result is that the throughput advantages of the architecture β€” sparse MoE, Mamba-2 linear complexity β€” only become fully realizable under the memory constraints of FP8 deployment, which in turn requires the accuracy-preserving selective quantization.

4. Key Insights and Innovations

Innovation 1: Multi-Environment Simultaneous RLVR as a Solution to Catastrophic Forgetting in Post-Training

The dominant paradigm for reinforcement learning in LLM post-training β€” exemplified by DeepSeek-R1 (DeepSeek-AI, 2025a) and earlier work in the Nemotron lineage β€” has been to train on a single environment or a small, tightly related cluster of environments. The implicit assumption was that RL is a specialization step: you take a generally capable SFT model and sharpen it on a specific capability (math reasoning, code generation, instruction following). If you wanted a model that excelled at multiple capabilities, you either accepted the SFT baseline for some of them or trained separate expert models and routed between them at inference time, fragmenting your deployment.

This paper's central post-training insight β€” which I would argue is its most intellectually distinctive contribution β€” is that this assumption is wrong in a specific, diagnosable way. The problem is not that RL inherently causes forgetting; it's that sequential or single-environment RL causes the model's output distribution to drift toward the reward signal of that environment alone, collapsing the breadth acquired during SFT. The paper's diagnostic move is the observation in Section 3.2: "single environment training often results in un-recoverable degradation of other benchmarks." The word "un-recoverable" is telling β€” once the capability is lost during RL, subsequent training on other environments cannot restore it, suggesting that the parameter space has moved into a basin of attraction where the lost capabilities are no longer reachable through gradient descent.

The counterintuitive solution is simultaneity: train on competition math, competition coding, STEM QA, structured JSON outputs, instruction following, long-context retrieval, and multi-step agentic tool use all at once, in the same gradient steps, with a fixed per-domain ratio in each batch. The paper demonstrates (Figure 8) that this not only avoids catastrophic forgetting β€” it surpasses a heavily fine-tuned SFT baseline (SFT2, trained to full convergence at ~5 epochs) across all evaluated domains within 250 RL training steps. This is not incremental: it means that the RL signal provides a form of learning that additional SFT epochs cannot replicate, and that this learning is only accessible when the environments are trained jointly rather than sequentially.

Why does simultaneity work? The paper doesn't provide a theoretical explanation, but the empirical mechanism is implied by the curriculum design (Section 3.2.2, Figure 7): when environments are trained together, the gradient from one environment acts as a regularizer on the policy update from another. A math problem's gradient that would push the model toward a degenerate "always reason with LaTeX" strategy is counterbalanced by a coding problem's gradient that requires structured code output. The domains constrain each other, preventing any single reward signal from dominating the policy update. This is fundamentally different from data mixing during SFT, where the model is simply exposed to diverse examples without the adversarial pressure of a verifier that rejects incorrect outputs. In RLVR, the model receives negative signal (zero or low reward) for outputs that would be perfectly acceptable in a different domain, creating a more stringent multi-objective optimization landscape.

The significance of this finding extends beyond this specific model. It establishes that multi-environment RLVR is not merely a convenience (training one model instead of many) but a requirement for reaching capabilities beyond what SFT alone can achieve. If this finding generalizes β€” and the paper's diverse environment suite suggests it might β€” then the field's post-training methodology should shift from sequential specialization to simultaneous multi-capability training as the default. The fact that this is NVIDIA's "first effort to scale up reinforcement learning in the post-training stage" (Section 3) and that it required building dedicated infrastructure (NeMo Gym, NeMo RL) to coordinate rollouts across heterogeneous environments underscores that this is a fundamental infrastructure and methodological contribution, not a trivial hyperparameter tweak.

Innovation 2: Architecture-Aware Selective Quantization as a Deployment Necessity, Not an Afterthought

Quantization is typically treated as a post-hoc optimization β€” something you do to a finished model to make it smaller and faster, often with a shrug about the 1–3% accuracy loss as "acceptable for deployment." The standard approach is uniform quantization: apply the same precision reduction (FP8, INT8, INT4) to all layers, perhaps with a calibration step to minimize activation range clipping, and accept that some benchmarks will regress. Prior work on MoE model quantization (including DeepSeek-V3's FP8 training and Qwen3's deployment configurations) largely follows this uniform paradigm.

Nemotron 3 Nano's quantization story (Section 4, Figure 11) is intellectually distinctive because it reframes quantization as an architectural design constraint, not a deployment add-on. The key finding is that the throughput gains from FP8 KV cache quantization β€” which are essential for achieving the 3.3Γ— inference throughput advantage claimed in Figure 1 β€” are only practical if you selectively preserve specific architectural components at higher precision. The paper systematically ablates this: quantize the attention layers to FP8 and accuracy collapses; quantize the KV cache without preserving the preceding Mamba layers and the error propagates through the attention mechanism; quantize everything uniformly and you lose the accuracy that makes the throughput advantage meaningful. The "sweet spot" in Figure 11 β€” 99% median accuracy recovery with ~250% throughput improvement β€” is an emergent property of the specific layer pattern: 6 self-attention layers + their 6 preceding Mamba layers in BF16, everything else in FP8.

What makes this a conceptual contribution rather than an engineering report is the diagnostic logic: the paper identifies which layers are sensitive and why. Attention layers are sensitive because the softmax nonlinearity amplifies small quantization errors β€” a perturbation of 0.5% in a QK dot product can become a 5% change in the attention distribution after softmax, which then propagates through the value aggregation. The preceding Mamba layers are sensitive because they provide the input to the attention computation; quantizing them feeds amplified error into an already-sensitive operation. The Mamba-2 state-space layers and MoE expert FFNs are empirically robust because their computations (structured state updates, element-wise nonlinearities) don't have the same error-amplification dynamics. This is not a claim the paper states explicitly in these terms, but it's the clear implication of the ablation pattern in Figure 11.

This insight changes how one should think about model architecture design. If you know during architecture development that quantization will be essential for deployment throughput (because MoE sparsity alone isn't enough β€” the memory savings from FP8 KV cache are what enable the batch sizes that realize the throughput gains), then the architecture itself should be designed to be quantization-aware: minimizing the number of attention layers, placing them strategically so that their preceding layers can be grouped for mixed-precision preservation, and ensuring that the bulk of the model uses quantization-robust operations (Mamba-2, FFNs with squared ReLU). The paper doesn't claim to have designed the architecture this way ab initio, but the selective quantization result retroactively validates the architectural choices: having only 6 attention layers out of 52 makes selective BF16 preservation feasible; a dense Transformer with 52 attention layers would require keeping far more parameters at higher precision, eroding the throughput gain.

This is a fundamental shift from "quantize and pray" to "design for quantizability," and it has downstream implications for any architecture that aims to push the inference-throughput frontier. Future work that combines Mamba, MoE, and attention layers should anticipate which specific sub-networks will need mixed precision, and the ablation methodology in Figure 11 provides a template for doing that systematic sensitivity analysis.

Innovation 3: Group-Relative Length Control as a Targeted Intervention Against Reasoning Verbosity Bloat

The observation that RLHF causes response length to increase is well-documented (DeepSeek-AI, 2025a; Team et al., 2025), but the standard interpretation has been that this is a form of reward hacking β€” the model learns that longer responses score higher under whatever reward model is used, regardless of content quality. The typical countermeasure is a global length penalty: subtract a constant times the response length from the reward. This is simple but has a well-known failure mode: it penalizes legitimate verbosity on problems that genuinely require long answers, creating a tradeoff where the penalty must be tuned per-task to avoid degrading performance on complex prompts.

Nemotron 3 Nano's Group Relative Length Control (Section 3.3.2) is a conceptual reframing of the length problem. The key diagnostic move is recognizing that the verbosity increase during RLHF is not reward hacking in the traditional sense β€” the GenRM is not fooled by length, since it evaluates response quality independently. Rather, the model learns to allocate more inference-time compute to "reasoning" (generating more thinking tokens) in order to produce higher-quality final answers, which in turn score higher under the GenRM. This is a rational strategy from the model's perspective: more thinking β†’ better answers β†’ higher reward. The problem is that for many RLHF prompts (general chat, creative writing, simple instruction following), this additional reasoning is wasteful β€” the questions don't require multi-step logical deduction, and the thinking tokens produce no marginal improvement in answer quality while consuming inference budget and annoying users with verbose output.

The innovation is the group-relative framing: instead of applying an absolute length penalty, make the length incentive relative to the other responses generated for the same prompt. Equation 4 normalizes reasoning length so that the shortest response in the group gets a bonus of +1 (before centering) and the longest gets 0. The centering step (Equation 5) makes the adjustment zero-sum within the group, preserving the total reward scale. The quality gate (only awarding the bonus to responses in the top 20% by GenRM score) prevents the degenerate strategy of producing short but low-quality responses.

Why is this intellectually distinctive rather than just a clever reweighting? Because it leverages a specific property of the RLHF setup that global penalties ignore: the difficulty of being concise varies per prompt. For a prompt like "Explain quantum computing to a 5-year-old," truly helpful answers will be short β€” the constraint is built into the task. For a prompt like "Draft a detailed project proposal," truly helpful answers will be long. A global length penalty forces the model to compromise between these competing pressures, producing medium-length answers that are suboptimal for both. The group-relative mechanism sidesteps this entirely: it only incentivizes relative conciseness within a group of responses to the same prompt. If all responses to a complex prompt are naturally long, the length bonus/penalty terms approximately cancel out (the zero-mean property), and the GenRM's quality signal dominates. If one response is significantly shorter than the others and still high-quality, it gets rewarded.

The result β€” 30% verbosity reduction without accuracy loss β€” validates the mechanism, but the conceptual contribution is broader: it demonstrates that length control should be prompt-conditional and quality-gated, and it provides a specific, lightweight mechanism (requiring no additional models, no prompt engineering, and no per-task tuning) to achieve this. The use of a percentile threshold (80th) rather than an absolute quality cutoff is particularly elegant: it adapts to the difficulty of the prompt. On easy prompts where most responses are high-quality, the 80th percentile threshold is high, and only truly excellent short responses get the bonus. On hard prompts where even the best responses are mediocre, the threshold is lower, and conciseness is still rewarded among the top quintile. This is a fundamental refinement of the length penalty concept that should generalize to any RLHF pipeline using group-based policy optimization (GRPO, PPO with batched rollouts).

Innovation 4: Synthetic Data as Pretraining Data β€” the RQA Dataset's Two-Step Generation Design

Most synthetic data generation for LLM pretraining follows a straightforward pattern: take a seed document, prompt a teacher model to generate a question about it, and use the question-answer pair as training data. This is the approach behind the DQA (Diverse QA) dataset in Section 2.2.4, and it produces useful but ultimately predictable training examples β€” the questions mirror the seed documents' content and structure, and the model learns to associate specific text patterns with answers.

The Reasoning Question-Answer (RQA) dataset (Β§2.2.4, "Synthetic STEM Reasoning") is intellectually distinctive because of its two-step generation design that deliberately maximizes the teacher model's reasoning engagement rather than its retrieval or paraphrasing capabilities. The pipeline works as follows: (1) present a seed STEM document to Qwen3-235B-A22B-Thinking-2507 and ask it to generate a difficult graduate-level scientific reasoning question inspired by the document but not requiring access to it; (2) present the generated question to the same model without the original seed document and ask it to produce a reasoning trace and answer.

The conceptual move here is subtle but significant. In a standard one-step generation pipeline, the teacher model sees both the seed and its own generated question, so the answering step is effectively an extension of the question-generation context β€” the model can "cheat" by relying on the same internal representations that produced the question. The two-step design breaks this dependency: the answering model has no access to the seed, so it must genuinely reason through the question from first principles. This forces the generation to produce questions that are self-contained and answerable without external context β€” a property that downstream models must learn to handle during pretraining.

More importantly, it changes the nature of the synthetic data. Instead of producing examples that teach the model "here is a passage, here is a fact from it, recall the fact in response to a question," the two-step design produces examples that teach "here is a complex scientific question, here is a multi-step reasoning chain that derives the answer." The difference is between training for retrieval-augmented generation (RAG) and training for autonomous reasoning. When these RQA examples are included in pretraining (as part of the 31.7 billion tokens in the Pretraining-Specialized-v1 dataset), they reinforce correlations between advanced STEM topics that are rarely co-observed in web-scale data β€” exactly the kind of cross-domain reasoning that the InfiniByte cross-breeding dataset also targets, but through a different mechanism (reasoning chain generation vs. problem generation).

The 4.3 million demonstrations are filtered to remove model-specific idiosyncrasies (e.g., Qwen3's characteristic phrasing patterns) and limited to 8192 characters, which prevents the pretraining model from memorizing teacher-model artifacts. This filtering is essential because the goal is not to distill Qwen3-Thinking's specific reasoning style but to teach the general skill of multi-step scientific reasoning by example. The fact that this filtering is aggressive enough to discard examples that take more than 8192 reasoning tokens to generate suggests that the pipeline prioritizes quality and cleanliness over volume β€” a notable design choice in an era where "more tokens" is often treated as inherently better.

This is a methodological innovation rather than a performance gain β€” the paper doesn't isolate the contribution of RQA to downstream benchmarks. But it represents a specific, replicable advance in synthetic data design: if you want pretraining data that teaches reasoning rather than retrieval, decouple the question-generation and answer-generation steps so that the answerer must reason from scratch. This insight is generalizable beyond STEM to any domain where multi-step inference is more valuable than factual recall.

5. Experimental Analysis

Evaluation Methodology

  • Datasets. The paper evaluates on a wide suite of benchmarks. For base model evaluation (Table 2): MMLU (5-shot), MMLU-Pro (5-shot CoT), AGIEval-En (3/5-shot CoT), HumanEval (0-shot), MBPP-Sanitized (3-shot), GSM8K (8-shot), MATH (4-shot), MATH-500 (avg@32), ARC-Challenge (25-shot), HellaSwag (10-shot), OpenBookQA (0-shot), PIQA (0-shot), WinoGrande (5-shot), RACE (0-shot), MMLU Global Lite (5-shot), MGSM (8-shot), and RULER at 64K, 128K, and 256K (0-shot). For post-trained model evaluation (Table 3): MMLU-Pro, AIME25 (with and without tools), GPQA (with and without tools), LiveCodeBench v6, SciCode, HLE (with and without tools), MiniF2F (pass@1 and pass@32), Terminal Bench (hard subset), SWE-Bench (OpenHands harness), TauBench V2 (Airline, Retail, Telecom), BFCL v4, IFBench (prompt), Scale AI Multi Challenge, Arena-Hard-V2 (Hard Prompt, Creative Writing, Average), AA-LCR, RULER-100 at 256K/512K/1M, MMLU-ProX (averaged over languages), and WMT24++ (enβ†’xx). Test splits follow standard community protocols, with MATH-500 evaluated via pass@1 estimated from 32 samples.

  • Base models. The primary model is Nemotron 3 Nano 30B-A3B (31.6B total, 3.2B active parameters). The base model comparisons use Qwen3-30B-A3B-Base as the primary competitor (Table 2). The post-trained model is compared against Qwen3-30B-A3B-Thinking-2507 and GPT-OSS-20B-A4B (Table 3). The paper does not compare base model accuracy to GPT-OSS-20B because "no base model was released with it" (Section 2.6). For the FLOPs-matched comparison, the paper does not provide a formal pretraining-vs-inference tradeoff analysis as in the reference example; instead, throughput comparisons are empirical measurements on specific hardware (single H200 GPU, Section 4.3).

  • Metrics. Primary metrics are accuracy (acc) or normalized accuracy (acc_norm) for most benchmarks, with greedy decoding at temperature 0. For MATH-500, avg@32 is reported (pass@1 estimated from 32 samples). For code evaluations (HumanEval, MBPP), the Evalplus sanitization method is applied. Throughput is measured in output tokens per second per GPU on a single H200, using the best configuration between vLLM and TRT-LLM for each model (Section 1). For the quantization ablation (Figure 11), accuracy recovery is defined as the median recovery rate across all benchmarks relative to the BF16 baseline. Relative throughput improvement is measured under identical hardware constraints (8K input / 16K output, maximum batch size for each configuration).

  • Baselines. The primary baselines are Qwen3-30B-A3B-Thinking-2507 (Yang et al., 2025a) and GPT-OSS-20B-A4B (OpenAI, 2025). For base model comparisons, Qwen3-30B-A3B-Base is the sole competitor. For post-trained evaluations, the paper uses officially reported numbers whenever available; if a benchmark is not officially reported, values are taken from ArtificialAnalysis (AA); if neither source provides results, the paper may compute scores itself using official evaluation protocols (Section 3.4.1). The Qwen3 comparisons use the "Thinking-2507" variant specifically, not the base instruct model, making this a comparison against a reasoning-optimized model.

  • Generation budget / compute accounting. For post-training throughput measurements, the scenario is fixed at 8K input tokens and 16K output tokens on a single H200 GPU. Both FP8 (weights and activations) and BF16 configurations are tested, with the best result from vLLM or TRT-LLM selected per model. GPT-OSS-20B uses mxfp4 for weights and bfloat16 for activations (as specified in Section 1). For the quantization ablation (Figure 11), throughput is measured with maximum possible batch sizes under identical hardware constraints, since "more aggressively quantized models can accommodate larger batch sizes due to lower memory footprint" (Section 4.3 caption). This is a critical design choice: the throughput comparison is not at fixed batch size but at maximum batch size, which favors quantized configurations that free KV cache memory.

  • Cross-validation / statistical protocol. For the post-trained evaluations, the paper relies on standard benchmark evaluation protocols through Nemo Evaluator SDK and Nemo Skills Harness, with identical configurations across models to ensure fair comparison. For the quantization ablation (Figure 11), accuracy recovery is computed as the median across all evaluated benchmarks (Table 4), a robustness measure against outlier regressions on individual benchmarks. The prompt sensitivity analysis (Appendix E, Table 8) evaluates models using multiple prompts per dataset varying in wording, instruction granularity, problem placement, and answer formatting, computing the standard deviation of prompt averages as the sensitivity metric β€” a methodological strength that acknowledges benchmark score brittleness to prompt engineering. Each prompt is evaluated across eight seeds to reduce sampling noise. Lower sensitivity scores (all below 1 for Nemotron 3 Nano) indicate stronger stability to routine prompt variations.

Main Quantitative Results

Base Model Performance

Table 2 presents a head-to-head comparison between Nemotron 3 Nano 30B-A3B Base and Qwen3-30B-A3B-Base across general knowledge, code, math, commonsense understanding, reading comprehension, multilingual, and long-context benchmarks. Nemotron 3 Nano achieves superior results on 15 of the 18 reported metrics:

  • Code: HumanEval 78.05 vs. 70.73 (+7.32), MBPP-Sanitized 75.49 vs. 73.15 (+2.34). The gap is substantial on HumanEval, suggesting the code pretraining data pipeline (Nemotron-CC-Code-v1, Nemotron-Pretraining-Code-v2 with synthetic augmentation and transpilation) provides a meaningful advantage.

  • Math: GSM8K 92.34 vs. 89.01 (+3.33), MATH 82.88 vs. 61.14 (+21.74), MATH-500 avg@32 78.63 vs. 55.08 (+23.55). The MATH and MATH-500 gaps are the largest in the table, likely reflecting the extensive synthetic math data (textbook generation, SFT-style math included in pretraining, RQA and DQA datasets, plus the Phase 2 math allocation doubling from 6.4% to 12.5%).

  • General Knowledge: MMLU 78.56 vs. 81.07 (-2.51) β€” one of the few Qwen3 wins. MMLU-Pro 65.05 vs. 61.71 (+3.34), reversing the trend, and AGIEval-En 68.32 vs. 63.12 (+5.20). The MMLU gap suggests Qwen3's base knowledge breadth is slightly better, while Nemotron's CoT capability (MMLU-Pro uses chain-of-thought) provides an advantage on reasoning-heavy knowledge tasks.

  • Long Context: RULER at 64K: 87.50 vs. 63.55 (+23.95); at 128K: 82.92 vs. 60.69 (+22.23); at 256K: 75.44 (Qwen3 not reported). These are large, consistent gaps. The paper's long-context extension methodology (121B token LC-phase with mixed 512K/4K sequence lengths, document QA data scaled 3Γ— from Nemotron 2, synthetic retrieval-focused data) produces dramatically better long-context retrieval capabilities than Qwen3's approach.

  • Multilingual: MMLU Global Lite 74.47 vs. 76.84 (-2.37) β€” a Qwen3 win. MGSM 83.00 vs. 82.53 (+0.47) β€” essentially tied. The multilingual picture is mixed, with Qwen3 having a slight edge on knowledge-based multilingual tasks but parity on math reasoning across languages.

  • Commonsense Understanding: ARC-Challenge 91.89 vs. 94.45 (-2.56) β€” Qwen3 win. HellaSwag 85.56 vs. 83.14 (+2.42), OpenBookQA 46.20 vs. 44.80 (+1.40), PIQA 84.33 vs. 81.01 (+3.32), WinoGrande 79.64 vs. 78.22 (+1.42). The commonsense picture is broadly favorable, with ARC-Challenge as a notable counterexample.

The pre-alignment base checkpoint comparison (Appendix A, Table 5) provides additional context: Nemotron 3 Nano's pre-alignment base trailed Qwen3 on several metrics (MMLU 78.44 vs. 81.07, HumanEval 69.51 vs. 70.73, MGSM 78.93 vs. 82.53), but the improved base model intended for release (Table 2) closed or reversed these gaps. Specifically, MATH improved from 80.80 to 82.88, HumanEval from 69.51 to 78.05, and MGSM from 78.93 to 83.00 between the pre-alignment and release checkpoints. This indicates that architectural or training improvements after the alignment pipeline was initialized meaningfully boosted base model capabilities, particularly in code and math.

MMLU-redux evaluations (Appendix B, Table 6) provide deeper insight into reasoning capabilities. Enabling CoT reasoning yields a substantially larger gain for Nemotron 3 Nano than for Qwen3: +5.27 average improvement across all MMLU-redux categories vs. +0.79 for Qwen3. The STEM category shows the most dramatic difference: +12.84 for Nemotron vs. +3.00 for Qwen, suggesting that Nemotron's base model is better at leveraging chain-of-thought for mathematical and scientific reasoning specifically. On MMLU-redux Tweak (which alters problem details like numerical values and equations), Nemotron improves by +4.96 overall while Qwen improves by +1.39, with Nemotron gaining +4.84 on STEM (vs. Qwen's -0.83). The divergent STEM trend on Tweak is notable: Qwen's accuracy actually decreases when problems are perturbed, suggesting some STEM performance on the original MMLU may be due to memorization rather than genuine reasoning capability.

Post-Trained Model Performance

Table 3 is the central results table for the post-trained model, comparing Nemotron 3 Nano against Qwen3-30B-A3B-Thinking-2507 and GPT-OSS-20B across reasoning, agentic, chat, long-context, and multilingual benchmarks. The headline claim from Section 1 β€” "Nemotron 3 Nano achieves better or on-par accuracy than competitive models while having up-to 3.3Γ— higher inference throughput" β€” is supported by the pattern of results, though with specific qualifications per category:

  • Reasoning (no tools): AIME25: Nemotron 89.06 vs. Qwen3 85.00 (+4.06) vs. GPT-OSS 91.70 (-2.64). GPT-OSS leads on pure math reasoning without tools, representing the paper's main accuracy concession in the reasoning category. GPQA (no tools): 73.04 vs. 73.40 (essentially tied with Qwen3) vs. 71.50 (+1.54 over GPT-OSS). LiveCodeBench v6: 68.25 vs. 66.00 (+2.25) vs. 61.00 (+7.25) β€” the strongest relative advantage over GPT-OSS. SciCode: 33.28 vs. 33.00 vs. 34.00 (tight cluster). HLE (no tools): 10.57 vs. 9.80 vs. 10.90 (tight cluster). The no-tools reasoning picture is competitive but not dominant: Nemotron 3 Nano leads on AIME25 over Qwen3, trails GPT-OSS on AIME25, and otherwise clusters tightly.

  • Reasoning (with tools): AIME25 (with tools): 99.17 vs. GPT-OSS 98.7 (+0.47). GPQA (with tools): 75.00 vs. GPT-OSS 74.20 (+0.80). HLE (with tools): 15.48 vs. GPT-OSS 17.30 (-1.82). Tools close or reverse the AIME25 gap with GPT-OSS (from -2.64 to +0.47), suggesting Nemotron's tool-integrated reasoning traces during SFT (generated with GPT-OSS 120B as teacher) successfully transfer tool-use capability. Qwen3 numbers for tools are not reported (marked with dashes in Table 3), limiting comparison.

  • Agentic: SWE-Bench (OpenHands): Nemotron 38.76 vs. Qwen3 22.00 (+16.76) vs. GPT-OSS 34.00 (+4.76). Terminal Bench (hard subset): 8.51 vs. 5.00 vs. 10.00 (GPT-OSS leads). TauBench V2 Average: 49.04 vs. 47.70 (+1.34) vs. 47.50 (+1.54). BFCL v4: 53.76 vs. Qwen3 46.40 (+7.36) β€” GPT-OSS not reported. SWE-Bench is the standout agentic result, with a 16.76-point lead over Qwen3. The TauBench breakdown reveals domain-specific differences: Airline 48.00 (trails Qwen3 at 58.00, leads GPT-OSS at 38.00), Retail 56.91 (trails Qwen3 at 58.80, leads GPT-OSS at 54.80), Telecom 42.21 (dominates Qwen3 at 26.30, trails GPT-OSS at 49.70). The Telecom result is an outlier: Nemotron nearly doubles Qwen3's score but trails GPT-OSS by 7.49 points. The agentic category overall shows a consistent pattern: Nemotron 3 Nano substantially outperforms Qwen3 and is competitive with or slightly ahead of GPT-OSS, with SWE-Bench as the strongest differentiator.

  • Chat and Instruction Following: IFBench (prompt): 71.51 vs. 51.00 (+20.51) vs. 65.00 (+6.51). This is one of the largest absolute gaps in the table and represents a core strength claim. Arena-Hard-V2 Average: 67.65 vs. 57.80 (+9.85) vs. 48.55 (+19.10). The Arena-Hard-V2 breakdown shows Hard Prompt: 72.10 vs. 49.60 vs. 71.20 (Nemotron leads Qwen3 by 22.50, essentially ties GPT-OSS); Creative Writing: 63.20 vs. 66.00 vs. 25.90 (Qwen3 leads by 2.80, Nemotron dramatically outperforms GPT-OSS by 37.30). Scale AI Multi Challenge: 38.45 vs. 44.75 (-6.30) vs. 33.75 (+4.70) β€” a notable Qwen3 lead. The IFBench and Arena-Hard-V2 Hard Prompt results are the strongest evidence for the paper's claim of chat/instruction-following superiority, while Scale AI Multi Challenge and Creative Writing show competitive positioning rather than dominance.

  • Long Context: AA-LCR: 35.85 vs. 59.00 (-23.15) vs. 34.00 (+1.85). This is the largest negative gap for Nemotron and the clearest Qwen3 advantage in the table. Long-context agentic reasoning appears to be a relative weakness. RULER-100 at 256K: 92.92 vs. 89.40 (+3.52); at 512K: 91.25 vs. 84.00 (+7.25); at 1M: 86.34 vs. 77.50 (+8.84). The RULER results are consistently positive, with the gap widening at longer contexts. GPT-OSS has a 128K context limit and cannot be evaluated on these longer RULER settings. The contrast between AA-LCR (with reasoning on, large deficit) and RULER (with reasoning off, consistent lead) suggests that Nemotron's long-context retrieval is strong but its long-context reasoning (multi-hop, agentic) is weaker than Qwen3's.

  • Multilingual: MMLU-ProX (avg over languages): 59.50 vs. Qwen3 77.60 (-18.10) vs. GPT-OSS 69.10 (-9.60). This is a substantial deficit and the second-largest negative gap in the table. WMT24++ (enβ†’xx): 86.20 vs. 85.60 (+0.60) vs. 83.20 (+3.00) β€” translation is competitive. The MMLU-ProX gap suggests that Nemotron's multilingual reasoning capability is significantly behind both competitors, despite competitive translation performance. This may reflect the composition of multilingual pretraining data (19 languages at 5% allocation, with a translation-to-English pipeline that may have prioritized English-centric knowledge).

Throughput Comparisons

Figure 1 reports relative inference throughput on a single H200 GPU for the 8K input / 16K output scenario: Nemotron 3 Nano is 3.3Γ— faster than Qwen3-30B-A3B-Thinking-2507 and 2.2Γ— faster than GPT-OSS-20B. These are the headline throughput numbers cited throughout the paper. The measurement methodology uses FP8 for both weights and activations for Nemotron 3 Nano and Qwen3, while GPT-OSS-20B uses mxfp4 for weights and bfloat16 for activations. The best configuration from vLLM and TRT-LLM is selected per model.

Table 4 and Figure 11 provide the quantization-accuracy tradeoff data. The FP8 model achieves approximately 99% median accuracy recovery relative to BF16. Individual benchmark regressions include: AIME25 (no tools) from 89.06 to 87.71 (-1.35), AIME25 (with tools) from 99.17 to 98.80 (-0.37), GPQA (no tools) from 73.04 to 72.47 (-0.57), GPQA (with tools) from 75.00 to 73.40 (-1.60), LiveCodeBench from 68.25 to 67.62 (-0.63), SciCode from 33.28 to 31.88 (-1.40), HLE (no tools) from 10.57 to 10.33 (-0.24), HLE (with tools) from 15.48 to 14.27 (-1.21). Agentic benchmarks show modest regressions: TauBench Average from 49.04 to 47.04 (-2.00), with Airline dropping from 48.00 to 44.79 (-3.21) as the largest individual regression. BFCL v4 drops from 53.76 to 53.15 (-0.61). Notably, IFBench improves from 71.51 to 72.19 (+0.68), a rare positive quantization effect. AA-LCR improves from 35.85 to 36.06 (+0.21). MMLU-ProX improves from 59.50 to 59.63 (+0.13).

The throughput-accuracy tradeoff ablation (Figure 11) explores nine quantization configurations on a single H100 with 8K input / 16K output. The key finding: quantizing the KV cache to FP8 dramatically increases throughput (comparing attn-BF16, KV-BF16 at ~100-110% throughput with attn-BF16, KV-FP8 at ~150-160% throughput), but this gain can only be realized without excessive accuracy degradation when attention layers are kept in BF16. Configurations with attention in FP8 (attn-FP8, KV-FP8) achieve higher throughput (~200%+) but drop accuracy recovery to ~95-96%. The selective quantization configuration (attn-BF16, KV-FP8, with the preceding Mamba layers also in BF16) achieves ~250% throughput improvement while maintaining ~99% median accuracy recovery β€” the sweet spot the paper selects for the released FP8 model.

RLVR Training Dynamics

Figure 9 tracks benchmark performance throughout RLVR training (500 steps) across eight metrics: AALCR, AIME25, GPQA, IFBench Prompt, LiveCodeBench, MMLU Pro, SciCode, and Tau Average. All metrics show consistent improvement: AALCR from ~20 to ~34, AIME25 from ~81 to ~88, GPQA from ~65 to ~74, IFBench from ~50 to ~64, LiveCodeBench from ~63 to ~69, MMLU Pro from ~74 to ~77.5, SciCode from ~27 to ~34, Tau Average from ~40 to ~49. The improvement curves are smooth and monotonic for most metrics, with no signs of degradation or overfitting within the training horizon. AALCR shows the steepest relative improvement, nearly doubling from its starting value, while MMLU Pro shows the most modest improvement (~3.5 points).

Figure 8 compares RLVR training against two SFT checkpoints: SFT1 (the RLVR starting point, ~3 epochs of SFT) and SFT2 (trained to full convergence, ~5 epochs). RLVR surpasses SFT1 within the first ~50 steps across all four shown metrics (GPQA, LiveCodeBench, AIME 2025, IFBench Prompt). More importantly, RLVR surpasses SFT2 within ~100-150 steps on GPQA, ~50-100 steps on AIME25, and ~150-200 steps on IFBench, while matching or exceeding SFT2 on LiveCodeBench. This demonstrates that a modest number of RLVR steps provides learning beyond what can be achieved by additional SFT epochs alone.

Figure 7 compares curriculum sampling against random sampling for an intermediate SFT checkpoint, maintaining identical domain ratios. Across GPQA, LiveCodeBench, AIME 2025, and IFBench Prompt, curriculum sampling shows stable improvement throughout training whereas random sampling shows erratic or flat trajectories. On IFBench, random sampling actually degrades performance (from ~55 to ~50) while curriculum sampling improves from ~55 to ~65. This is the paper's primary evidence that the curriculum design is necessary for simultaneous multi-environment training.

Figure 6 illustrates the curriculum mechanism: batch-wise pass rates decrease from ~0.62 to ~0.46 over 600 training steps, reflecting the shift from high-pass-rate (easier) to low-pass-rate (harder) samples as training progresses.

GenRM Training and RLHF

Figure 10 tracks GenRM performance across JudgeBench, RM-Bench, and an internal validation set over 800 training steps. JudgeBench accuracy rises from ~0.66 to ~0.74, RM-Bench from ~0.866 to ~0.878, and Internal-Val-Set from ~0.626 to ~0.646. All three curves show continued improvement throughout training, with no plateau, suggesting further scaling of GenRM training could yield additional gains. The smoothness of improvement validates the GRPO training approach and the reward formulation (Equation 1).

The RLHF results are described qualitatively: "verbosity level reduces 30% during the training without sacrificing accuracy" (Section 3.3.2). This is the main quantitative outcome from the Group Relative Length Control mechanism. No separate RLHF ablation table is provided comparing training with and without length control, so the 30% figure cannot be disaggregated into the contributions of the Length-Normalized Reward Adjustment alone versus the Quality-Gated Conciseness Bonus.

Ablation Studies and Robustness Checks

Quantization sensitivity analysis (Figure 11): The systematic exploration of nine quantization configurations demonstrates that attention layers are the primary sensitivity bottleneck. Quantizing attention to FP8 (attn-FP8 configurations) consistently reduces accuracy recovery to ~95-97% regardless of other settings. KV cache FP8 quantization (comparing attn-BF16, KV-BF16 to attn-BF16, KV-FP8) provides ~50% throughput improvement without significant accuracy loss, but only when attention is kept in BF16. The combined selective configuration (attn-BF16, KV-FP8, preceding Mamba layers in BF16) achieves the Pareto-optimal throughput-accuracy tradeoff. The ablation validates that the 6 attention layers and their 6 preceding Mamba layers are the minimal set requiring BF16 preservation.

Calibration dataset choice (Section 4.1): Using post-training reasoning SFT data as the PTQ calibration dataset yielded "slightly better accuracy recovery compared to the cnn_dailymail dataset." On-policy generations from the BF16 model showed no additional benefit over the SFT-based calibration data. This suggests that calibration data distribution matching the target deployment distribution is important, but on-policy data (which is more expensive to generate) is unnecessary.

DPO for tool hallucination reduction (Appendix C, Table 7): An additional alignment experiment using DPO after SFT (not part of the main pipeline but explored as a complementary technique). Training with as few as 50 steps at LR 3e-6, batch size 128, yields: AIME25 (no tools) accuracy improves from 80.88% to 84.58%, with hallucination rate dropping from 1.25% to 0%. GPQA (no tools) accuracy improves from 65.15% to 69.19%, with hallucination rate dropping from 8.33% to 0.7%. The small amount of DPO training (50 steps) producing meaningful hallucination reduction and accuracy improvement suggests that preference-based fine-tuning provides a signal complementary to RLVR for tool-use calibration. The paper reports that even 10K preference samples (or fewer) yielded similar benefits, indicating high sample efficiency. Notably, the final released model "does not rely on DPO, because reinforcement learning already achieved comparable performance" (Appendix C), implying that the multi-environment RLVR and RLHF stages successfully addressed tool hallucination without explicit DPO.

Prompt sensitivity analysis (Appendix E, Table 8): Evaluated across four benchmarks (GPQA, MMLU-Pro, Comp-Math-24-25, LiveCodeBench), Nemotron 3 Nano shows prompt sensitivity scores of 0.42, 0.41, 0.77, and 0.83 respectively β€” all below 1.0. Qwen3 scores: 0.59, 0.31, 0.51, 1.05. GPT-OSS scores: 1.91, 1.46, 1.14, 1.02. GPT-OSS shows markedly higher sensitivity (>1.0 on all benchmarks, nearly 2.0 on GPQA), meaning its benchmark performance varies substantially with minor prompt wording changes. Nemotron and Qwen3 both show sub-1.0 sensitivity on most benchmarks, with Nemotron being slightly more stable than Qwen3 on GPQA (0.42 vs. 0.59) and Comp-Math (0.77 vs. 0.51 being Qwen3's only lower score). Low sensitivity scores are a robustness property, not an accuracy property: they indicate that reported benchmark scores are reliable rather than artifacts of specific prompt engineering.

MMLU-redux variants (Appendix B, Table 6): The ablation on MMLU-redux with and without CoT, and on MMLU-redux Tweak (perturbed test examples), reveals that Nemotron 3 Nano benefits substantially more from chain-of-thought reasoning than Qwen3. The STEM CoT gain of +12.84 (vs. Qwen3's +3.00) suggests that Nemotron's base knowledge can be more effectively operationalized through explicit reasoning, consistent with the inclusion of extensive reasoning trace data during pretraining (RQA, DQA, SFT-style math/code data). The Tweak results β€” Nemotron improves +4.96 while Qwen improves +1.39 β€” indicate better generalization to perturbed problem formulations, which the paper attributes to reduced memorization and stronger underlying reasoning capability.

Critical Assessment

The experiments in this paper collectively support a systems contribution β€” the integration of architecture, data, training methodology, and quantization produces a model with competitive or superior accuracy and substantially higher throughput than comparable open models. The evidence for this overarching claim is strong across the breadth of evaluated benchmarks, though specific sub-claims vary in evidentiary strength.

The claim that Nemotron 3 Nano achieves "better or on-par accuracy than competitive models" (Section 1) is conditionally supported. On reasoning without tools (Table 3), the model is competitive but not dominant: trails GPT-OSS on AIME25 (-2.64), ties Qwen3 on GPQA, leads on LiveCodeBench (+7.25 over GPT-OSS). On agentic tasks, the model shows strong differentiation: SWE-Bench +16.76 over Qwen3 and +4.76 over GPT-OSS, BFCL v4 +7.36 over Qwen3. On chat/instruction following, the IFBench gap of +20.51 over Qwen3 is the strongest single-benchmark advantage. But these strengths are balanced by clear weaknesses: AA-LCR trails Qwen3 significantly (-23.15), MMLU-ProX trails both competitors (-18.10 vs. Qwen3, -9.60 vs. GPT-OSS), and Scale AI Multi Challenge trails Qwen3 (-6.30). The claim of "on-par or better" is true on average if the evaluation suite is taken at face value, but the weight assigned to each benchmark matters: a deployment prioritizing multilingual reasoning would find this model substantially weaker than Qwen3; a deployment prioritizing SWE-Bench agentic tasks would find it substantially stronger.

The claim of 3.3Γ— throughput advantage (Figure 1) is well-supported but represents a specific measurement point. The measurement uses a single H200 GPU, 8K input / 16K output, FP8 for Nemotron and Qwen3, and the best of vLLM/TRT-LLM per model. Throughput is notoriously sensitive to batch size, sequence length, hardware, and inference engine optimization. A model that is 3.3Γ— faster at 8K/16K may not be 3.3Γ— faster at 128K/1K (long-context, short generation) or at very small batch sizes (interactive single-query latency). The paper does not provide a throughput curve across different input/output length combinations, which would be necessary to assess whether the advantage generalizes across deployment scenarios. The 2.2Γ— advantage over GPT-OSS-20B at its native precision (mxfp4 weights, bfloat16 activations) is a different measurement condition than the Qwen3 comparison, making direct throughput comparison between the two competitors approximate.

The missing experiment: throughput comparison at equivalent accuracy. The paper compares throughput of the quantized models directly, but does not provide an isotonic regression or accuracy-matched throughput comparison. For instance: if Nemotron 3 Nano at BF16 achieves accuracy X on some benchmark, and Qwen3 at FP8 achieves the same accuracy X, what is the throughput ratio? This would isolate the architectural throughput advantage from the quantization advantage, but is not reported.

The RLVR curriculum ablation (Figure 7) demonstrates that curriculum sampling outperforms random sampling, but uses a specific curriculum design (Gaussian target distribution with linearly decreasing mean). No alternative curriculum strategies (e.g., hard-first, round-robin across domains, dynamic task weighting based on recent performance) are compared, so the claim is specific to "this curriculum beats random" rather than "this is the optimal curriculum." Similarly, the fixed domain ratios in each batch are stated but not ablated β€” different ratios might produce different tradeoffs between domains. The re-profiling step (which constructs a new curriculum when training plateaus) is described but its specific trigger condition and frequency are not specified, making reproducibility challenging.

The 30% verbosity reduction from Group Relative Length Control is reported without an accompanying ablation table showing the reward curves, accuracy trajectories, or length trajectories with and without the mechanism. The reader cannot assess whether the 30% reduction came primarily from the Length-Normalized Reward Adjustment, the Quality-Gated Conciseness Bonus, or their interaction. An ablation decomposing the contributions of the individual components (\lambda coefficients, \beta bonuses, percentile threshold Ο„_p) would strengthen the claim that this is a general-purpose mechanism rather than a well-tuned set of hyperparameters.

The GenRM is trained from Qwen3-235B-A22B-Thinking-2507, a model from the same family as the primary competitor (Qwen3-30B-A3B-Thinking-2507). While the GenRM is a different scale (235B-A22B vs. 30B-A3B), the use of a Qwen-family model as the reward signal for training a Nemotron model raises a potential concern: if the GenRM shares biases or preferences with the Qwen3 model family, the RLHF stage might be aligning Nemotron 3 Nano toward Qwen3-like behaviors rather than toward a truly independent quality standard. The paper does not address this potential circularity.

The base model improvement between pre-alignment and final checkpoint (Tables 5 vs. Table 2) is attributed to "an improved base model intended for release" but the specific changes (data mixture? hyperparameters? training duration?) are not specified. The MATH improvement (+2.08), HumanEval improvement (+8.54), and MGSM improvement (+4.07) are substantial, and the reader cannot determine whether these came from additional training tokens, improved data, or architectural changes. This is a transparency gap in an otherwise unusually detailed technical report.

The long-context evaluation reveals a tension in the results. RULER-100 at 256K/512K/1M (reasoning off) shows consistent Nemotron leads over Qwen3: +3.52, +7.25, +8.84. But AA-LCR (reasoning on) shows a massive Qwen3 lead: 59.00 vs. 35.85 (-23.15). The evaluations differ in both task design (RULER tests retrieval; AA-LCR tests agentic reasoning) and reasoning mode. The paper does not report RULER with reasoning on, nor AA-LCR with reasoning off, to disambiguate whether the gap is task-driven or reasoning-mode-driven. This limits conclusions about which specific long-context capabilities are strong vs. weak.

The quantization ablation (Figure 11) is with batch size maximized per configuration rather than fixed batch size. This is a fair methodology for measuring peak throughput under memory constraints, but it means the throughput numbers are not at a standardized workload β€” higher-throughput configurations also process more tokens simultaneously, which can inflate tokens-per-second metrics if the larger batch introduces efficiency gains (better GPU utilization) independent of the model architecture. A fixed-batch-size throughput comparison would isolate the per-token compute cost difference from the memory-footprint difference.

The evaluation suite is comprehensive but omits certain common benchmarks: no TriviaQA, NaturalQuestions, or other knowledge-intensive retrieval benchmarks; no MT-Bench or AlpacaEval for chat quality; no HumanEval+ or MBPP+ for code robustness evaluation (only standard HumanEval and MBPP-Sanitized). The inclusion of HLE (Humanity's Last Exam), SciCode, Terminal Bench, and TauBench V2 reflects a preference for challenging, verifiable tasks over standard leaderboard benchmarks, which is methodologically defensible but means some comparisons to other models' standard benchmarks are unavailable.

Statistical significance is not reported for any comparison. The MATH-500 evaluation uses 32 samples for pass@1 estimation, providing a point estimate without confidence intervals. Other benchmarks use greedy decoding, producing a single deterministic score. The prompt sensitivity analysis (Appendix E) partially addresses this by measuring score variation across prompts, but does not provide per-benchmark standard errors for the comparisons with Qwen3 and GPT-OSS. Given the test set sizes (e.g., 500 questions for MATH, 30 for AIME25) and reported score differences as small as 0.47 percentage points (AIME25 with tools: 99.17 vs. 98.7), some of the "better" claims may fall within sampling error.

Overall, the paper's experimental evidence strongly supports its characterization as a systems contribution achieving a favorable accuracy-throughput tradeoff. The specific numerical claims about throughput advantage and accuracy parity are well-supported within their measurement conditions. The most robustly substantiated capabilities are SWE-Bench agentic tasks (+16.76 over Qwen3), IFBench instruction following (+20.51 over Qwen3), and long-context retrieval at 256K–1M (RULER). The most clearly documented weaknesses are long-context agentic reasoning (AA-LCR) and multilingual reasoning (MMLU-ProX), where the model lags both competitors substantially. Future work that isolates the contributions of individual architectural, data, and training innovations β€” and that evaluates on additional model families beyond Qwen3 and GPT-OSS β€” would strengthen the generalizability of these findings.

6. Limitations and Trade-offs

The Difficulty Estimation Cost Is Not Factored Into Efficiency Claims

The paper's central throughput advantage claims assume the model is being served for inference against a known benchmark or deployment workload β€” but do not account for any form of prompt-difficulty estimation, adaptive routing, or dynamic budget allocation at inference time. Unlike the reference paper's compute-optimal test-time scaling framework (which estimates difficulty per prompt), Nemotron 3 Nano treats all prompts uniformly: the same model, same architecture, same forward pass for every input regardless of complexity. This is not a defect β€” it is the standard deployment paradigm β€” but it means the claimed 3.3Γ— throughput advantage is entirely architectural (MoE sparsity, Mamba-2 linear complexity, FP8 quantization), not algorithmic in the sense of spending fewer FLOPs on easy problems.

Consequence. If a deployment were to adopt an adaptive inference strategy β€” for instance, activating fewer experts on simple tokens or using early-exit for easy questions β€” the throughput advantage might be even larger than reported, but the paper provides no framework for such adaptive allocation. Conversely, the paper cannot be compared to systems that do use inference-time budget allocation (like the flagship paper's compute-optimal test-time scaling), because no difficulty estimation or routing cost is built into the pipeline. A practitioner considering whether to deploy Nemotron 3 Nano vs. a smaller model with adaptive inference cannot use this paper to make that decision.

Evidence. Nowhere in the paper β€” including the throughput measurement methodology (Section 1), the RLVR curriculum (Section 3.2.2, Figure 6), or the quantization ablation (Section 4.3, Figure 11) β€” is there any mechanism that allocates different compute budgets to different prompts. The model processes all tokens through the same forward pass: 6 experts activated out of 128 for every token in every MoE layer, all 52 layers executed for every sequence.

Mitigation status. The paper does not address this limitation because it falls outside the scope of the contribution. The authors are not claiming to optimize test-time compute allocation; they are claiming to build the most throughput-efficient model for uniform inference. This is a scope limitation, not an oversight β€” but it means the paper's efficiency claims are specific to the uniform-inference paradigm and do not compete with or compare against adaptive-inference approaches.

The Throughput Advantage Depends on a Specific Hardware and Software Stack

The headline 3.3Γ— throughput advantage over Qwen3-30B-A3B-Thinking-2507 and 2.2Γ— over GPT-OSS-20B (Figure 1, Section 1) is measured on a single H200 GPU with FP8 quantization, using the best of vLLM or TRT-LLM per model, under an 8K input / 16K output scenario, with batch size maximized to fill memory. Each clause of that sentence is a constraint on generalizability:

  • Single H200 GPU: Throughput advantages from reduced memory footprint (FP8 KV cache, MoE sparsity) are most pronounced when memory is the bottleneck. On multi-GPU setups or hardware with larger memory pools (H200 has 141GB HBM3e), the memory-pressure advantage shrinks, and compute-bound throughput may differ.
  • FP8 quantization (Nemotron and Qwen3) vs. mxfp4 + bfloat16 (GPT-OSS): The three models are not quantized to the same precision. Nemotron 3 Nano and Qwen3 compete at FP8 (weights and activations), while GPT-OSS-20B uses mxfp4 weights and bfloat16 activations β€” a different precision regime. A comparison at uniform precision (e.g., all BF16 or all FP8) would isolate architectural throughput from quantization throughput.
  • Best of vLLM or TRT-LLM: Inference engine optimizations are model-specific. A model that benefits disproportionately from TRT-LLM's kernel fusion or vLLM's paged attention may show inflated throughput in a "best engine" comparison relative to a model with less mature engine support. The paper does not provide per-engine throughput numbers, preventing assessment of engine-specific variance.
  • 8K input / 16K output: Throughput ratios vary with sequence length. The Mamba-2 layers provide approximately linear sequence complexity vs. attention's quadratic complexity, so the throughput advantage should theoretically grow at longer contexts. But the paper only reports throughput at a single (input, output) pair, with no throughput curve across sequence lengths. At very short sequences, the constant overheads of MoE routing and FP8 dequantization may dominate, reducing or reversing the advantage.
  • Maximized batch size per configuration: As noted in Section 5, the quantization ablation (Figure 11) uses the maximum batch size each configuration can fit in memory. This is fair for measuring peak throughput under memory constraints, but it means the 3.3Γ— number reflects both reduced per-token compute and better GPU utilization from larger batches. A fixed-batch-size comparison would isolate the per-token advantage.

Consequence. A practitioner running Nemotron 3 Nano on different hardware (A100, H100, L40S), at different sequence lengths (e.g., 128K input / 512 output for long-document QA), or with a different inference engine (TensorRT-LLM only, or vLLM only, or SGLang) may observe substantially different throughput ratios. Deployments that are latency-bound (batch size = 1, interactive single queries) rather than throughput-bound may see smaller gains because the memory-footprint advantage matters less and per-token latency overheads (MoE gating, loading expert weights) become more prominent. The paper does not provide latency numbers at all.

Evidence. The throughput measurement conditions are specified in Section 1 and Section 4.3, Figure 11. No throughput-vs-sequence-length curve is provided. No latency measurement (time-to-first-token, inter-token latency) is reported. Per-engine breakdowns are not provided.

Mitigation status. The paper is transparent about the measurement conditions but does not explore the sensitivity of the throughput advantage to these conditions. This is a practical limitation for deployment planning: the 3.3Γ— number is a point estimate under specific, favorable conditions, not a guaranteed throughput multiplier across all deployment scenarios.

Multilingual and Long-Context Agentic Reasoning Are Weak Points With Large Gaps

Two of the three largest negative gaps in the post-trained evaluation (Table 3) represent capabilities that are increasingly important for global and enterprise deployment:

  • MMLU-ProX (multilingual reasoning): Nemotron 3 Nano scores 59.50 vs. Qwen3's 77.60 (a βˆ’18.10 gap) and GPT-OSS's 69.10 (βˆ’9.60). This measures advanced reasoning across multiple languages, not just translation. The model trails both competitors substantially.

  • AA-LCR (long-context agentic reasoning): Nemotron 3 Nano scores 35.85 vs. Qwen3's 59.00 (βˆ’23.15). The gap to GPT-OSS is negligible (+1.85), but the Qwen3 gap is the largest single-benchmark deficit in the entire evaluation suite. This benchmark evaluates agentic reasoning over long contexts with reasoning enabled.

These gaps are not offset by strengths elsewhere in the same categories. For multilingual, the WMT24++ translation score (86.20 vs. 85.60, a narrow win) shows that the model translates well but reasons poorly in non-English languages. For long context, the RULER-100 retrieval results (86.34 at 1M tokens vs. 77.50, a strong win) show that the model retrieves information well from long contexts but reasons over that retrieved information poorly (at least by AA-LCR's metric).

Consequence. Deployments in multilingual settings (European, Asian, or global enterprise) that require reasoning β€” not just translation β€” will find Nemotron 3 Nano substantially weaker than Qwen3 on this capability. Deployments that require multi-hop reasoning over long documents (legal contract analysis, scientific literature review, multi-document financial analysis with interactive follow-up questions) will find the long-context agentic reasoning gap with Qwen3 to be severe. These are not niche capabilities: they are standard requirements for enterprise-grade LLM deployment in international organizations and for any application involving large document corpora.

Evidence. Table 3, MMLU-ProX row (Qwen3 77.60 vs. Nemotron 59.50) and AA-LCR row (Qwen3 59.00 vs. Nemotron 35.85). Figure 1 bar chart (AA-LCR: Nemotron 35.85, Qwen3 59.00, GPT-OSS 34.00). The multilingual pretraining data allocation (Section 2.3) is 5% across 19 languages, with a translation-to-English pipeline that may have prioritized English-centric knowledge over native multilingual reasoning. The long-context training data (Section 2.5) emphasizes retrieval ("synthetic retrieval-focused data") and document QA, which maps to RULER's strengths but potentially not to AA-LCR's reasoning requirements.

Mitigation status. The paper does not diagnose or address these gaps. There is no ablation identifying whether the multilingual reasoning deficit stems from pretraining data composition (5% multilingual allocation, translation pipeline), architecture (expert specialization may favor English-dominant tokens), or post-training (SFT data may be English-centric). The long-context reasoning gap is partially addressed by specifying that RULER is evaluated with reasoning off while AA-LCR uses reasoning on (Table 3 footnotes), but no experiment bridges these two evaluation regimes to determine whether the gap is reasoning-mode-specific or task-design-specific. These are areas for future work that the paper acknowledges only implicitly by reporting the numbers.

The Post-Training Pipeline's Success Depends on Infrastructure That Is Not Easily Replicated

The multi-environment simultaneous RLVR training (Β§3.2) β€” the paper's primary post-training innovation β€” relies on NeMo Gym and NeMo RL, custom infrastructure built to coordinate rollouts across heterogeneous environments (competition math with unit test verifiers, agentic tool-use with database state verification, structured JSON with schema checkers, long-context QA with LLM judges, etc.). Each environment has its own:

  • Verification backend (unit test execution, database state comparison, JSON schema validation, LLM judge API calls).
  • Rollout kernel (code execution sandbox, terminal emulator, tool-calling simulator).
  • Reward computation pipeline (some synchronous, some requiring async execution of tool calls).
  • Task distribution characteristics (17K math tasks, 135K STEM QA tasks, 690 workplace assistant tasks).

NeMo Gym abstracts these behind a server architecture (agent servers, model servers, resource servers) with standardized APIs, but this is custom, NVIDIA-built infrastructure. The paper open-sources NeMo Gym and NeMo RL (Section 3), but this does not eliminate the integration burden: a team attempting to replicate the multi-environment RLVR setup would need to:

  1. Implement or adapt their own environment servers for each task domain.
  2. Configure vLLM model servers with the specific prompt formats and generation parameters (max 49K tokens, overlong filtering).
  3. Set up resource servers for reward computation (unit test runners, database instances, schema validators, LLM judge deployments).
  4. Coordinate the curriculum sampling across domains with fixed per-batch ratios and Gaussian difficulty scheduling.
  5. Handle the re-profiling step that triggers when training plateaus (the trigger condition is not specified β€” Section 3.2.2 says "When training progress plateaus, we re-profile the tasks").

Consequence. While the model weights, data, and code are open-sourced, the training pipeline that produced the RLVR results is difficult to replicate outside NVIDIA's infrastructure environment. A research lab or startup attempting to reproduce the multi-environment RLVR training would face substantial engineering overhead β€” building and integrating environment servers, debugging coordination between NeMo RL and vLLM, tuning the curriculum parameters for their own model and task distribution. The paper's claim that this infrastructure "enables the broader community to facilitate large-scale RL training, as well as collaborative and distributed RL environment building" (Section 3) is aspirational but not yet realized: the community needs not just the frameworks but also reference implementations of the environment servers and integration recipes.

More subtly, the specific hyperparameters of the RLVR setup β€” 128 prompts per step, 16 generations per prompt, Gaussian target distribution with linearly decreasing mean, re-profiling trigger conditions, frozen MoE router weights with aux-free bias updates β€” were likely discovered through expensive trial-and-error on NVIDIA's compute infrastructure. The paper reports the final configuration but not the search process that discovered it. A team with a different model architecture or task distribution may need to re-discover these hyperparameters, which the open-source release of the framework does not itself solve.

Evidence. The infrastructure description (Section 3.2.4) provides the architectural abstraction (agent/model/resource servers) but not deployment scripts, Docker configurations, or integration examples. The open-source release is cited as GitHub repositories (footnotes for NeMo Gym and NeMo RL), but the paper does not specify whether the exact environment configurations used for Nemotron 3 Nano's training are included in those repositories. The re-profiling trigger is described qualitatively ("when training progress plateaus") without a quantitative criterion (validation loss threshold, moving average of reward, number of steps without improvement).

Mitigation status. The paper open-sources both NeMo Gym and NeMo RL, and releases the RL training data (Nemotron-RL-Data). This is a genuine contribution to reproducibility, but it addresses the framework layer while leaving the integration layer to the community. The paper does not claim that reproduction is easy; it claims that the tools are available. A detailed reproduction guide or reference deployment configuration would substantially lower the replication barrier.

The GenRM Is a Competitor-Family Model, Introducing Potential Evaluation Circularity

The Generative Reward Model used for RLHF (Section 3.3.1) is built from Qwen3-235B-A22B-Thinking-2507 (Yang et al., 2025a) β€” a model from the same family as the primary competitor, Qwen3-30B-A3B-Thinking-2507. The GenRM is a different scale (235B-A22B vs. 30B-A3B, roughly 8Γ— more total parameters), but it shares the Qwen3 architecture, pretraining data distribution, and likely similar behavioral biases (preferences for certain response styles, reasoning patterns, formatting conventions).

The RLHF stage uses this GenRM to provide the reward signal that shapes Nemotron 3 Nano's final chat and instruction-following behavior (Section 3.3.2). If the GenRM systematically prefers responses that resemble Qwen3-family outputs β€” because its training data and architecture induce preferences correlated with its own model family β€” then the RLHF process may be aligning Nemotron 3 Nano toward Qwen3-like behavior rather than toward a truly independent quality standard.

Consequence. This has two implications:

  1. Evaluation circularity: Nemotron 3 Nano's strong performance against Qwen3 on chat and instruction-following benchmarks (IFBench: +20.51, Arena-Hard-V2 Average: +9.85, Table 3) cannot be entirely disentangled from the possibility that the RLHF process taught Nemotron to produce outputs the Qwen3-family GenRM prefers β€” which may or may not correlate with human preference or benchmark ground truth. If the GenRM has Qwen3-specific preferences that are not aligned with general human preferences, Nemotron 3 Nano may have been trained toward a biased target.
  2. Unfairness concern: A reader comparing Nemotron 3 Nano to Qwen3 should know that Nemotron's final training stage used a Qwen3-family model as its teacher. This is not disqualifying β€” knowledge distillation across model families is standard practice β€” but the paper does not discuss it as a potential confound in the Qwen3 comparison.

Evidence. The GenRM is explicitly identified in Section 3.3.1 as "Qwen3-235B-A22B-Thinking-2507." Its training data includes HelpSteer3 (Wang et al., 2025b), a subset of lmarena-ai/arena-human-preference-140k (Chiang et al., 2024), and a synthetic safety blend (Appendix D). These are human-preference datasets, not Qwen3-generated data, which partially mitigates the circularity concern (the GenRM is trained on human preferences, not on Qwen3 outputs). However, the GenRM's architecture and initialization (Qwen3-Thinking) may still induce architectural biases in how it interprets and applies those human preferences.

Mitigation status. The paper does not address this potential circularity. It does not provide an analysis of whether the GenRM shows bias toward Qwen3-family outputs (e.g., by evaluating the GenRM on response pairs where one response is from Qwen3 and the other from a different model family, controlling for quality). It does not include an ablation with a non-Qwen GenRM (e.g., a Llama-based reward model) to demonstrate that the RLHF benefits are not GenRM-family-specific. This is a transparency gap in an otherwise detailed technical report, and it is particularly relevant because the published checkpoint name includes "Qwen-3-Nemotron-235B-A22B-GenRM" (Section 1), making the connection explicit for anyone who inspects the released model.

The Paper Does Not Characterize Latency, Which Is the Binding Constraint for Interactive Agentic Use Cases

The entire throughput narrative of the paper β€” 3.3Γ— higher tokens/second, MoE sparsity reducing per-token cost, FP8 enabling larger batch sizes β€” is framed around throughput (tokens per second at maximum batch size). But the paper's own motivation for agentic deployment (Section 2) emphasizes interactive, multi-step agentic workflows where the model generates a response, a tool is called, the tool returns results, and the model generates again β€” a sequence of serial model calls each dependent on the previous step's output.

In this serial regime, the binding constraint is not throughput (how many tokens the GPU can produce per second when processing many sequences simultaneously) but latency (how long it takes to produce a single response, from time-to-first-token through end-of-generation, when the batch size is 1). MoE architectures introduce a latency penalty that throughput measurements can mask: at large batch sizes, the cost of loading expert weights from memory is amortized across many tokens that use those experts. At batch size 1, each token activates 6 experts out of 128, requiring loading 6 expert weight matrices from GPU memory β€” a memory-bandwidth-intensive operation that may be slower than a dense model's FFN layer at the same active parameter count. Mamba-2's recurrent generation (state updates that are sequential per token) may also have different latency characteristics than attention's parallelizable key-value cache lookups.

Consequence. A practitioner deploying Nemotron 3 Nano for an interactive coding assistant, a conversational agent, or a SWE-Bench-style autonomous software engineering agent β€” where the model makes one call, waits for tool output, then makes another call β€” cares primarily about per-call latency, not throughput. If Nemotron 3 Nano's time-to-first-token is higher than Qwen3's (due to MoE expert loading overhead) or if its per-token generation latency is similar despite higher throughput (because the throughput advantage comes from batch processing that single-query deployments can't exploit), the 3.3Γ— throughput advantage is irrelevant to the deployment decision.

The paper evaluates on SWE-Bench (38.76, strong), Terminal Bench (8.51, competitive), TauBench V2 (49.04 average, competitive), and BFCL v4 (53.76, strong) β€” all agentic benchmarks that in real deployment involve serial model calls. But the throughput numbers that accompany these benchmarks (Figure 1, 3.3Γ—) are measured under conditions (maximized batch size, 8K/16K sequence lengths) that do not match the serial, batch-size-1 inference pattern of agentic evaluation. The accuracy results are valid; the claim that the throughput advantage translates to these agentic use cases is unsubstantiated.

Evidence. The paper reports throughput (output tokens/second/GPU) at 8K/16K with maximum batch size (Section 1, Figure 1, Figure 11). No latency numbers are reported anywhere: no time-to-first-token, no per-token latency at batch size 1, no end-to-end latency for a representative agentic trajectory. The ISL/OSL throughput bar in Figure 1 is labeled "ISL/OSL 8k/16k" without batch size specification. The quantization ablation (Figure 11) explicitly uses maximum batch size per configuration. The SWE-Bench evaluation (Table 3) uses the OpenHands harness, which makes sequential model calls, but the latency of those calls is not reported.

Mitigation status. The paper does not address this limitation. It does not provide a latency characterization, does not discuss the throughput-vs-latency tradeoff for MoE architectures, and does not qualify its throughput claims with respect to the interactive agentic use cases that motivate the paper. This is a significant gap for a paper whose primary contribution is the throughput-accuracy Pareto frontier: throughput is only one half of the inference-efficiency story, and for the agentic applications that represent the paper's most distinctive evaluation (SWE-Bench, Terminal Bench, TauBench), latency is arguably the more important half.

7. Implications and Future Directions

How This Work Changes the Landscape

This paper causes a methodological shift in how the field approaches post-training for generalist models, moving from the sequential specialization paradigm toward simultaneous multi-capability reinforcement learning. The finding is specific and empirically grounded: single-environment RL training causes "un-recoverable degradation" of capabilities acquired during SFT (Section 3.2), while multi-environment simultaneous RLVR with curriculum sampling not only preserves but surpasses even heavily over-trained SFT baselines (Figure 8, across GPQA, LiveCodeBench, AIME 2025, and IFBench within 250 steps). This is not a reframing of an existing idea β€” it is a diagnostic correction to a widespread implicit assumption that RL is necessarily a specialization step that trades breadth for depth.

The magnitude of this shift should not be overstated. The paper does not provide a theoretical account of why simultaneity prevents catastrophic forgetting; it demonstrates the empirical fact and provides a mechanism (Gaussian curriculum with fixed domain ratios). But the practical implication is clear: if you are building a generalist agentic model, you should train on all your RL environments at once, not sequentially. This reverses the practice established by DeepSeek-R1 (DeepSeek-AI, 2025a), which applied RL primarily to math and code reasoning, and by earlier Nemotron models (Nemotron 2 Nano), which trained on fewer environments. The paper does not claim that sequential training cannot work β€” only that it is substantially riskier and, at minimum, requires careful mitigation of forgetting that the simultaneous approach avoids by construction.

The paper also establishes a new integration baseline for the throughput-accuracy Pareto frontier. Prior to this work, a practitioner choosing an open model in the ~30B parameter class faced a three-way tension: you could get strong reasoning (Qwen3-Thinking), strong agentic capability (GPT-OSS), or strong throughput (Qwen3's MoE architecture, but without the Mamba-2 speedup). Nemotron 3 Nano demonstrates that all three can coexist in a single open model, and that the integration effort β€” architecture design (MoE + Mamba-2 hybrid), data engineering (25T tokens, 3T new), post-training methodology (simultaneous multi-environment RLVR + GenRM-based RLHF with length control), and deployment optimization (selective FP8 quantization) β€” is itself a first-class research contribution. This does not make any individual component obsolete, but it raises the bar for what a "competitive" open release should include: weights alone are insufficient; the training recipe, data, and quantization strategy are all part of the contribution bundle.

The paper reconciles a tension in the quantization literature between aggressive precision reduction (which improves throughput but degrades accuracy) and conservative mixed-precision (which preserves accuracy but leaves throughput on the table). The selective quantization ablation (Figure 11) demonstrates that the bottleneck is not quantization in general but quantization of specific architectural components: the 6 self-attention layers and their 6 preceding Mamba layers. Everything else β€” the remaining 40 Mamba layers, all MoE expert FFNs, the KV cache β€” can be FP8 with near-zero accuracy loss. The finding generalizes beyond this specific model: any hybrid Mamba-Attention-MoE architecture should anticipate that attention layers and their immediate input layers will need higher precision at deployment, and should minimize the count of such layers (6 out of 52 here) to maximize the fraction of the model that can be aggressively quantized. This makes quantization awareness a first-class architectural design constraint, not a post-hoc optimization.

A research direction that becomes less attractive in light of this paper is single-domain RL specialization followed by model merging or routing. If simultaneous multi-environment RLVR can achieve better results across all domains simultaneously (Figure 8), the additional complexity of training separate expert models and maintaining a routing infrastructure becomes harder to justify, at least for models up to the 30B-parameter scale. The paper does not prove that this scales to much larger models or more diverse environment suites, but it shifts the burden of proof: the default should be simultaneous training unless there is a specific reason that it fails.

Follow-Up Research This Work Enables

Disentangling the contribution of MoE sparsity versus Mamba-2 linear complexity to the throughput advantage. The paper reports a 3.3Γ— throughput advantage over Qwen3-30B-A3B-Thinking-2507 (Figure 1) but does not isolate how much of this comes from the Mamba-2 layers reducing sequence-processing cost versus the MoE layers reducing per-token compute. An ablation that replaces the Mamba-2 layers in Nemotron 3 Nano with standard self-attention (keeping the MoE layers and layer pattern intact) while matching the same active parameter count would measure the Mamba-specific throughput gain. Conversely, replacing the MoE layers with dense FFNs of equivalent total FLOPs would isolate the MoE-specific gain. A strong follow-up would train three architectures at smaller scale (e.g., 5B active parameters) β€” pure dense Transformer, MoE-only Transformer, and the full Mamba-MoE hybrid β€” on identical 1T-token corpora and measure both throughput curves (across input/output lengths) and benchmark accuracy. This would produce a decomposition of the architectural throughput advantage that the current paper's single-model report cannot provide.

Quantifying whether simultaneous RLVR scales to more diverse and adversarial environments. The paper demonstrates simultaneous training across 7 environment categories (competition math, competition coding, STEM QA, structured JSON, instruction following, long-context QA, agentic tool use). An open question is whether this approach remains stable as environments become more adversarial or contradictory β€” for example, training on both safety refusal (which requires declining harmful requests) and instruction following (which requires complying with user intent) simultaneously, where the reward signals pull the policy in opposite directions. A specific experiment: add a "red-teaming" environment that rewards the model for being helpful on jailbreak attempts, alongside a "safety" environment that rewards refusal, both in the same simultaneous RLVR setup. Measure whether the policy converges to a stable balance, oscillates, or collapses toward one extreme. If simultaneous training handles contradictory reward signals through the gradient averaging effect, this would substantially expand the scope of deployable RLVR. If it fails, it would identify a boundary condition β€” simultaneous RLVR works when environments are compatible but not when they are adversarial β€” which is equally important for guiding practice.

Comparative analysis of GenRM family bias in RLHF. The paper's RLHF stage uses a GenRM trained from Qwen3-235B-A22B-Thinking-2507 (Section 3.3.1), raising the concern that the reward signal may encode Qwen3-family preferences. A controlled experiment would train three GenRMs β€” one from Qwen3-Thinking (as in the paper), one from a Llama-family model of comparable scale, and one from a Nemotron-family model β€” on identical human preference data (HelpSteer3 + Arena-Human-Preference-140k subset), then run RLHF with each on an identical SFT checkpoint and measure the resulting policy's performance on both automated benchmarks and human evaluation. If all three GenRMs produce policies that converge to similar behavior, the family-bias concern is negligible. If the Qwen3-GenRM produces a policy that scores higher against Qwen3-preferring automatic judges (like Arena-Hard-V2's GPT-4.1 judge) but not in human evaluation, this would reveal a hidden alignment tax in using competitor-family reward models. This is a concrete, runnable experiment requiring model training but no novel infrastructure beyond what the paper open-sources.

Measuring latency at batch-size-1 for agentic deployment scenarios. The paper's throughput numbers (3.3Γ—, Figure 1) are measured with batch size maximized under memory constraints (Section 4.3, Figure 11). For the interactive agentic use cases that motivate the paper (SWE-Bench, TauBench V2, Terminal Bench), the binding constraint is latency at batch-size-1 β€” how long does a single model call take when the user is waiting for a response before the next tool can be called? A specific measurement study would benchmark time-to-first-token (TTFT) and inter-token latency for Nemotron 3 Nano, Qwen3-30B-A3B-Thinking-2507, and GPT-OSS-20B at batch size 1 across a range of input/output lengths (1K/1K, 8K/1K, 128K/1K), using identical hardware (single H200) and inference engine (vLLM, to control for engine-specific optimizations). The hypothesis to test: MoE expert loading overhead causes higher TTFT at batch-size-1 than dense models of equivalent active parameter count, potentially erasing the throughput advantage for serial agentic workflows. A negative result (Nemotron maintains latency parity with Qwen3 at batch-size-1) would strengthen the paper's agentic deployment claims. A positive result (substantial latency penalty) would bound the applicability: Nemotron is preferred for throughput-bound batch inference but not for latency-bound interactive use.

Investigating whether the RQA two-step generation design generalizes to non-STEM reasoning domains. The RQA dataset (Section 2.2.4) uses a specific two-step pipeline β€” question generation from seed document, then answer generation without seed access β€” to force the teacher model to produce self-contained reasoning questions and genuine reasoning traces. This design is motivated by STEM reasoning, but the principle (decoupling question generation from answer generation to prevent the teacher from "cheating" via shared context) should apply to any domain where multi-step inference is more valuable than factual recall: legal reasoning (generate a question from a case summary, then answer it without the summary), medical diagnosis (generate a differential diagnosis question from a patient history, then reason through it without the history), or policy analysis. A specific follow-up would generate RQA-style datasets for law and medicine using the same two-step pipeline with a domain-appropriate teacher model, include them in a pretraining corpus, and measure whether downstream reasoning benchmarks in those domains (e.g., LegalBench, MedQA) improve relative to a baseline that includes only standard QA-style synthetic data. This would test whether the RQA design is a general reasoning-data methodology or a STEM-specific trick.

Stress-testing the selective quantization strategy at INT4 precision. The paper demonstrates that keeping 6 attention layers and their preceding 6 Mamba layers in BF16 enables FP8 quantization of the remaining model with 99% median accuracy recovery (Figure 11). A natural next stress test: push to INT4 quantization for the non-sensitive layers (MoE expert FFNs and non-attention-adjacent Mamba layers), keeping the same 12 layers in BF16. This would probe whether the sensitivity pattern (attention + immediate predecessors are fragile, everything else is robust) holds at lower precision or whether a new set of sensitive layers emerges at INT4. A specific experiment: apply the same sensitivity analysis methodology from Figure 11 at INT4, produce the throughput-vs-accuracy tradeoff curve, and identify the new Pareto-optimal configuration. If INT4 is viable for the bulk of the model with the same BF16 preservation set, the throughput advantage could double again, making real-time agentic deployment on consumer GPUs feasible. If INT4 causes cascading failures across many layer types, it would establish that FP8 is a "sweet spot" precision for hybrid architectures and that further compression requires fundamentally different approaches (e.g., activation-aware quantization, per-channel quantization).

Practical Applications and Downstream Use Cases

Batch inference for code evaluation and software engineering pipelines. The paper's strongest agentic result is SWE-Bench at 38.76 (Table 3), a +16.76 advantage over Qwen3 and +4.76 over GPT-OSS. In a production software engineering pipeline β€” where a model processes hundreds of GitHub issues per day, each requiring 10–50 sequential model calls to explore the codebase, reproduce the bug, and generate a fix β€” the 3.3Γ— throughput advantage translates directly to cost savings or throughput capacity. Specifically, on a single H200 GPU, Nemotron 3 Nano can process approximately 3.3Γ— more SWE-Bench-style trajectories per day than Qwen3 at the same hardware cost. For an organization running continuous integration with automated bug-fixing, this means either a 3.3Γ— reduction in GPU-hours per issue or the ability to triage 3.3Γ— more issues on the same hardware budget. The 38.76 accuracy is not production-ready (61.24% of issues remain unsolved), but for issues below a difficulty threshold where accuracy is higher, this is a meaningful operational advantage.

Interactive coding assistants where throughput enables real-time response streaming. The LiveCodeBench v6 score of 68.25 (Table 3) and HumanEval of 78.05 (Table 2) position Nemotron 3 Nano competitively for code generation. For an interactive coding assistant (IDE plugin, command-line copilot), the 2.2–3.3Γ— throughput advantage over GPT-OSS and Qwen3 means that suggestion streaming β€” where the model generates code token-by-token as the developer types β€” can happen with lower latency or higher quality at the same latency budget. A developer who currently waits 500ms for a Qwen3-generated code completion could receive Nemotron 3 Nano's completion in 150ms (at 3.3Γ— throughput), or could receive a longer, more complete suggestion in the same 500ms window. The key caveat from the paper's limitations is that this benefit assumes throughput-bound serving (multiple concurrent users or prefill-heavy workloads); for a single-user, batch-size-1 interactive session, the benefit depends on latency characteristics that the paper does not measure (see Section 6, latency limitation). Deployments that batch multiple user requests (e.g., cloud-hosted coding assistants serving many developers simultaneously) are the strongest fit for this throughput advantage.

Long-document retrieval and RAG pipelines at 256K–1M token contexts. Nemotron 3 Nano's RULER-100 scores β€” 92.92 at 256K, 91.25 at 512K, 86.34 at 1M tokens (Table 3) β€” establish it as a strong retrieval model at extreme context lengths, outperforming Qwen3 by widening margins (+3.52 at 256K, +7.25 at 512K, +8.84 at 1M). For a retrieval-augmented generation (RAG) pipeline over large document corpora β€” legal discovery across millions of contracts, scientific literature review across thousands of papers, or enterprise knowledge base search β€” this enables loading entire document sets into context rather than chunking them into smaller passages. The throughput advantage compounds with context length: Mamba-2's linear sequence complexity means that processing a 512K-token context is not 64Γ— more expensive than an 8K context (as it would be for quadratic attention), making 1M-token RAG queries economically viable on a single GPU. A legal tech company processing discovery documents could use Nemotron 3 Nano to retrieve relevant passages from a 500K-token contract corpus in a single forward pass, rather than running dozens of shorter-context queries, reducing total inference cost and eliminating the need for complex chunking-and-aggregation logic. The AA-LCR deficit (βˆ’23.15 vs. Qwen3, Table 3) serves as a warning: this retrieval strength does not extend to multi-hop reasoning over those retrieved documents, so the pipeline should use Nemotron for the retrieval step and potentially a different model (or a human) for the reasoning step.

On-device or single-GPU agentic deployment for resource-constrained settings. The combination of 3.2B active parameters, FP8 quantization, and selective precision retention means Nemotron 3 Nano can serve interactive workloads on a single consumer or prosumer GPU (H200, H100, or potentially L40S/RTX 6000 Ada with 48GB memory). The BFCL v4 score of 53.76 (Table 3) and TauBench V2 average of 49.04 indicate functional tool-use capability. For a small startup or research lab without access to multi-GPU clusters, this means they can run a capable agentic model locally β€” handling customer support tool-calling tasks, automating internal workflows, or powering research assistants β€” without API costs or data privacy concerns. The 3.3Γ— throughput advantage specifically reduces the latency of multi-step tool-use trajectories, making local deployment more practical for time-sensitive applications. An open-source project maintaining infrastructure could deploy Nemotron 3 Nano on a single GPU to triage GitHub issues, run CI/CD diagnostics, or generate documentation, all without sending code to external APIs. The formal proofs capability (MiniF2F pass@1 of 50.03, pass@32 of 79.92) further supports this: automated theorem proving in Lean 4 can run locally, iteratively generating and checking proofs without cloud dependency.