Nvidia Nemotron 3 Ultra Review: The 550B Open Model (2026)

"Nemotron 3 Ultra" is Nvidia's largest open model to date: 550B total parameters, ~55B active through a Latent Mixture-of-Experts hybrid that interleaves Mamba-2, MoE and select Attention layers, under the permissive OpenMDW v1.1 license, with a context window Nvidia lists as up to 1M tokens. It shipped June 4, 2026 with pre-trained, post-trained, reward and NVFP4-quantized checkpoints — genuinely open weights, not a gated preview. This review covers what it is, whether you can realistically self-host it, what the benchmarks say (and who reported them), and where a hosted API makes more sense. We ran our own executed coding benchmark on it (it scored 9/9) — every accuracy number Nvidia publishes below is vendor-reported, and we say which is which.

What Nemotron 3 Ultra is

It is Nvidia's largest open-weight language model — 550B total parameters, ~55B active, released June 4, 2026. Announced at Computex 2026 and published on Hugging Face as NVIDIA-Nemotron-3-Ultra-550B-A55B, it is a Mixture-of-Experts model: the full 550B parameters exist, but only about 55B fire on any given token, which is what keeps inference tractable. Nvidia describes the design as a Mixture-of-Experts hybrid Mamba-Attention architecture with Latent MoE (LatentMoE) — it interleaves Mamba-2 state-space layers, MoE layers and a smaller number of Attention layers, and adds Multi-Token Prediction (MTP) layers to speed up decoding.

Two things make this release notable beyond the parameter count. First, Nvidia lists a context window of up to 1M tokens — genuinely long-context territory. Second, it is actually open: Nvidia shipped the pre-trained base, the post-trained instruct model, a reward model, and an NVFP4-quantized checkpoint, all under a permissive license. That is a fuller release than the single-checkpoint drops most vendors call "open." If you want the broader field, our best open-source LLM guide for 2026 puts it in context.

The Nemotron 3 Ultra spec sheet

Here is everything confirmed from Nvidia's primary sources in one place — the Hugging Face model card and Nvidia's research page. We have flagged the one figure that third-party blogs dispute.

* Nvidia's model card states "up to 1M tokens" without qualification. Some third-party blogs claim the 1M window only applies to the NVFP4/Blackwell variant and that the BF16 checkpoint is closer to 262K — that split is not stated on Nvidia's card, so we report the official figure and flag the discrepancy as unverified.

How open is it, really

More open than almost anything else at this scale. Nemotron 3 Ultra ships under the OpenMDW License Agreement v1.1, a permissive open model license. Crucially, Nvidia did not release a single instruct checkpoint and call it a day — it published the pre-trained base (useful if you want to do your own post-training), the post-trained instruct model, a reward model (for RLHF-style alignment work), and an NVFP4-quantized build for efficient inference on Blackwell hardware.

That matters for anyone who cares about control: you can inspect the weights, fine-tune on your own data, and run it in your own environment without a per-seat license or a usage gate. The usual caveat applies — "open weights" is not the same as "open training data," and a strict open-source-software purist will note the corpus is not fully disclosed. But for the practical questions most teams ask (can I download it, modify it, and deploy it commercially?), the answer here is yes.

Can you actually self-host 550B?

Technically yes, practically only if you own or rent data-center GPUs. This is the part the parameter count hides. A Mixture-of-Experts model still has to load all its experts into memory even though it only activates a slice per token — so the 550B total, not the 55B active, drives your VRAM bill.

In round numbers: at BF16 the weights are on the order of a terabyte, and even the NVFP4 4-bit checkpoint is roughly 275GB — several times what fits on a single 80GB GPU. So a realistic self-host means a multi-GPU node (eight high-memory data-center cards) or a small cluster, with tensor and expert parallelism to shard the model, plus headroom for the KV cache if you actually use the long context. This is a different universe from a model like gpt-oss-120b, which fits on a single card, or the smaller checkpoints you can run at home per our guide to running LLMs locally in 2026. Nemotron 3 Ultra is a serious infrastructure commitment, not a laptop model.

Benchmarks (and who reported them)

Nvidia's numbers look strong — but every one of them is vendor-reported. As of July 2026 no third-party lab had published an independent accuracy run, so treat Nvidia's scores below as first-party claims until Artificial Analysis, vals.ai or similar labs publish their own. To add at least one independent data point, we ran our own executed coding test:

Nvidia also reports a throughput story: in its own testing at an 8k-input / 64k-output profile, Nemotron 3 Ultra ran 5.9×, 4.8× and 1.6× faster than GLM-5.1-754B-A40B, Kimi-K2.6-1T-A32B and Qwen-3.5-397B-17B respectively, with what it calls on-par accuracy across benchmarks. That is a plausible pitch for a hybrid Mamba-MoE design — state-space layers are cheaper at long sequence lengths than pure attention — but it is a vendor comparison on a vendor-chosen workload, so weight it accordingly. The RULER-at-1M score is the one to watch: if independent labs confirm it, Nemotron 3 Ultra becomes a genuinely interesting long-context option. For how it stacks against other open models, see our open-source LLM roundup.

Self-host vs API: the honest math

Owning the weights is valuable; owning the hardware usually is not. The whole appeal of an open model is optionality — you can run it yourself. But "can" and "should" diverge fast at 550B. Here is the trade-off laid out plainly:

The break-even is utilization. A dedicated multi-GPU node only makes economic sense if you keep it near-saturated around the clock; below that, a per-token API is cheaper because you are not paying for idle silicon. On DataLLM Lab, Nemotron 3 Ultra is served through an OpenAI-compatible gateway at approximately $0.50 / $2.20 per 1M tokens (from our catalog) with a free variant, so you can evaluate the model before deciding whether self-hosting is worth the infrastructure. Point your existing client at our base URL and change the model id:

from openai import OpenAI

client = OpenAI(
    base_url="https://www.datallmlab.com/v1",
    api_key="YOUR_DATALLMLAB_KEY",
)

resp = client.chat.completions.create(
    model="nvidia/nemotron-3-ultra-550b-a55b",
    messages=[{"role": "user", "content": "Summarize this 400-page contract."}],
)
print(resp.choices[0].message.content)

Same SDK, same code shape as any other model — that is the point of an OpenAI-compatible API. Browse the full catalog on the models page or the pricing page.

Who Nemotron 3 Ultra is for

It is for teams that value openness and long context, and who either have serious hardware or are happy to rent it by the token. A quick decision guide:

Our honest read: Nemotron 3 Ultra is a legitimately interesting release — a fully-open, frontier-scale hybrid MoE with a credible long-context story, from a vendor with obvious hardware incentives to make big models run well. But Nvidia's accuracy claims are still vendor-only — our own executed coding run (9/9) is one independent point in their favor, not a full validation — and at 550B the self-host path is a data-center project, not a weekend one. The pragmatic move for most teams is to call it through an API, measure it on your tasks, and revisit self-hosting only if utilization and data-control needs justify the infrastructure. If it clears your evaluation bar, the openness is real and the license is permissive — a rare combination at this size.

FAQ