Nemotron 3 Ultra: What NVIDIA's 550B Open Model Is For

Most open-weight launches are judged on one question: does it beat the other open models on the leaderboard? Nemotron 3 Ultra is an awkward fit for that question. On several agentic coding scores it sits behind models released months earlier. On throughput, long-context retrieval and openness of the training pipeline it is unusually strong. Which of those matters depends entirely on what you are building.

NVIDIA released it on 4 June 2026 and describes it as the final and largest model of the Nemotron 3 family. It is a mixture-of-experts model with 550B total parameters and 55B active per token, and it is the sibling above Nemotron 3 Super and Nemotron 3 Nano.

What NVIDIA actually shipped

The release is broader than a single checkpoint. NVIDIA's research page lists four:

• 550B-A55B NVFP4 — post-trained and quantised to NVIDIA's 4-bit floating-point format.
• 550B-A55B BF16 — the same post-trained model at full precision.
• 550B-A55B Base — the pre-trained model before instruction tuning, for anyone who wants to run their own post-training.
• 550B-A55B GenRM — the generative reward model used during reinforcement learning.

Alongside them come datasets: a code pre-training set of 173B tokens of GitHub code collected through 30 September 2025, synthetic legal and specialised pre-training sets, and a post-training set covering agentic, reasoning and general behaviour. The recipes sit in NVIDIA's public Nemotron repository.

That last part is the rare thing. Plenty of labs publish weights. Very few publish the base model, the reward model and the post-training data together, which is what you need if you intend to reproduce or extend the training rather than just run inference.

A hybrid, not a plain transformer

The architecture interleaves Mamba-2 state-space layers with mixture-of-experts layers and a smaller number of attention layers. NVIDIA calls its expert design LatentMoE and adds multi-token prediction layers, which the model uses for native speculative decoding — drafting several tokens ahead and verifying them in one pass. If that technique is new to you, speculative decoding explained covers why it raises tokens per second without changing output quality.

Two practical consequences follow. Mamba layers do not grow a key-value cache with sequence length the way attention does, which is a large part of why a 1M-token context is tractable. And because only a minority of layers are attention, serving stacks need explicit support for the hybrid; a generic transformer runtime will not load it.

The model card states a context of up to 1M tokens, with serving examples defaulting to 256K and the full window enabled by a configuration flag. OpenRouter's paid listing shows 262,144 tokens at the time of writing, so check what your provider has actually configured before designing around the larger figure.

Reasoning is switchable through the chat template's enable_thinking flag, with a medium-effort mode that spends fewer reasoning tokens and a budget mechanism that caps the length of the reasoning trace.

The scores: strong at long context, middling at agentic code

These are vendor-reported numbers from the Hugging Face model card, and NVIDIA notes that several were run on internal scaffolding rather than open harnesses:

• RULER at 1M tokens — 94.7
• AA-LCR — 65.4
• SWE-bench Verified — 70.7
• Terminal-Bench 2.1 — 56.4
• LiveCodeBench v6 — 89.0
• GPQA (no tools) — 87.0
• MMLU-Pro — 86.8
• IFBench — 81.7
• Humanity's Last Exam — 26.7 without tools, 37.4 with them
• BrowseComp — 44.4

Put those next to the rest of the open field and the shape is clear. A SWE-bench Verified score of 70.7 trails DeepSeek V4 Pro's 80.6 and even the dense Qwen 3.6 27B's 77.2. Terminal-Bench 2.1 at 56.4 is well behind GLM-5.2's 81.0. If your workload is long-running repository agents, Ultra is not the leader.

The RULER result is the opposite story. Holding 94.7 at a full million tokens is a strong long-context retrieval number, and NVIDIA claims it beats other open models on that test. Retrieval at length is not the same as reasoning at length — see long context degradation — but it is the precondition for it.

Throughput is the real pitch

NVIDIA's headline claim is speed. On a setting of 8K input tokens and 64K output tokens, it reports 5.9 times the throughput of GLM-5.1, 4.8 times Kimi K2.6 and 1.6 times Qwen 3.5. That setting is deliberately long-output, which is where a reasoning model spends its time and where the Mamba layers and multi-token prediction pay off most.

Treat the multiples as vendor numbers on a vendor-chosen setup. But the direction is plausible from the architecture, and if you serve reasoning traffic at volume, throughput per GPU is what sets your cost, not a few points on a coding benchmark.

On hosted APIs, OpenRouter lists it at $0.60 per million input tokens and $2.40 per million output, with cached input at $0.12, at the time of writing. A :free variant also exists; like every free endpoint it is rate-limited and suits trying the model, not production traffic.

Licence and hardware: what self-hosting takes

The weights are published under the OpenMDW License Agreement version 1.1, which the model card says covers commercial and non-commercial use. It is not MIT, so read the text before you redistribute fine-tuned weights; open-weight licences compared explains what to look for.

The hardware floor is serious. The card lists a minimum of eight B200, GB200, B300 or GB300 GPUs, sixteen H100s or eight H200s, with eight B200s recommended for single-node BF16. At the time of writing TensorRT-LLM supports it only on Blackwell, with Hopper support planned. The NVFP4 checkpoint reduces the memory footprint, but it is still a data-centre model.

Ultra, Super or Nano

The family exists so you can pick a size. Choose Ultra when you need the strongest Nemotron 3 reasoning, the full long-context capability, or the base and reward models to run your own post-training. Choose Super when you want the same family behaviour on a fraction of the hardware, and Nano when latency and cost per call dominate. If you are on hosted APIs and only care about agentic coding scores, another open model may simply serve you better.

To decide, run your own tasks rather than trusting either set of numbers: take ten long-document questions and ten multi-step tool tasks from real work, run them with thinking on and at medium effort, and record accuracy, output tokens and wall-clock time. Ultra's claim is that it finishes faster at similar quality. That is cheap to check and expensive to assume.