NVIDIA's Nemotron 3 Ultra is the most important open-weight AI release of 2026 for one specific reason: it puts a 550-billion-parameter reasoning model with a 1-million-token context window into anyone's terminal, free, through an API key. It is not, however, the model that "kills Claude and Codex," and it is not "5x faster" in the way viral posts claim. This guide gives you the full picture: what Ultra actually is, honest benchmark comparisons, what it costs, who it is for, and a complete setup guide for OpenCode — plus how to build 3D websites with it in minutes, and the one limitation that catches everyone out.
Announced by Jensen Huang at Computex in Taipei on June 1, 2026, with weights released to Hugging Face on June 4, Ultra is the flagship of NVIDIA's Nemotron 3 family. It is open-weight under the Linux Foundation's OpenMDW-1.1 license, which permits commercial use, and NVIDIA also publishes the training data and recipes. That openness is the real story. The benchmark crown is not.
What Nemotron 3 Ultra actually is
Ultra is a sparse mixture-of-experts (MoE) model built on NVIDIA's Nemotron-H architecture, a hybrid that interleaves Mamba state-space layers with standard Transformer attention. Mamba layers compress long sequences into a fixed-size state instead of attending over every past token, which is what makes million-token context affordable; Transformer layers handle precise fact retrieval. Only about 55 billion of the 550 billion parameters activate for any given token — roughly 90% sparsity — so you get the capacity of a very large model at closer to the inference cost of a much smaller one, provided the serving stack can route experts efficiently.
Post-training runs SFT (supervised fine-tuning), then RLVR (reinforcement learning with verifiable rewards), then MOPD, then MTP boosting. Two more tricks matter for agent work: LatentMoE, which NVIDIA describes as calling four experts at the inference cost of one, and multi-token prediction, which predicts several tokens at once to cut generation time on long sequences. There is also inference-time reasoning-budget control, so you can trade thinking tokens for speed or accuracy. The model is text-only: no vision, no audio.
| Specification | Nemotron 3 Ultra |
|---|---|
| Total parameters | 550 billion (MoE) |
| Active parameters per token | ~55 billion (~10%) |
| Architecture | Hybrid Mamba-Transformer MoE (Nemotron-H), LatentMoE |
| Layers / experts | 108 layers, 512 experts per layer, top-22 activated |
| Pre-training | 20 trillion tokens (data through Sept 2025; post-training through May 2026) |
| Context window | 1,000,000 tokens native (NVFP4 on Blackwell); 262,144 on many hosted endpoints |
| Max output | ~65,536–66,000 tokens |
| Precision | BF16 broadly; NVFP4 optimized for Blackwell |
| License | OpenMDW-1.1 — open weights, commercial use permitted |
| Released | Announced June 1, 2026 (Computex); weights June 4, 2026 |
| Long-context retrieval | 94.7% on RULER at full 1M context (NVIDIA-reported) |
One context-window warning before you go further. The model natively supports 1 million tokens, but individual providers cap it: OpenRouter's paid endpoints list 262,144 tokens, while NVIDIA's own free endpoint lists the full 1 million. Always check your provider's listing before assuming 1M — the model is capable of it, your endpoint may not serve it.
The family: Nano, Super, Ultra
Ultra is one of three siblings, and picking the wrong one is the most common beginner mistake. Nano is the local-friendly worker, Super is the multi-agent coordinator, Ultra is the flagship reasoner.
| Model | Total / active params | Built for | Context |
|---|---|---|---|
| Nemotron 3 Nano | 30B / ~3B | Cheap, fast, high-volume steps: summarization, retrieval, routing, local experimentation | Up to 1M |
| Nemotron 3 Super | 120B / 12B | Multi-agent coordination, IT automation, planning across tools | Up to 1M |
| Nemotron 3 Ultra | 550B / 55B | Flagship reasoning, long-horizon agents, large codebases, deep research | Up to 1M |
For most readers, the practical rule is simple: experiment locally with Nano, build agent systems on Super or Ultra through the API, and only think about self-hosting Ultra if you run server infrastructure.
Honest benchmarks: does it kill Claude and Codex?
No. Say it plainly, because the viral claim is everywhere. On Artificial Analysis' Intelligence Index, Ultra scores about 48 (48.2 in BF16, 47.7 in NVFP4). Claude Opus 4.8 scores 61.4 and GPT-5.5 scores 60.2 on the same index — a gap of roughly 13 points. On the Coding Index, Opus 4.8 leads 74.3 against Ultra's 49.3. Ultra is the top US open-weight model, but China's Kimi K2.6 scores higher at about 54, so "best open model in the world" is also wrong — "best US open model" is the accurate claim.
| Benchmark | Ultra (BF16) | Claude Opus 4.8 | GPT-5.5 |
|---|---|---|---|
| AA Intelligence Index | 48.2 | 61.4 | 60.2 |
| AA Coding Index | 49.3 | 74.3 | — |
| SWE-bench Verified | 71.9% | — | — |
| Terminal-Bench 2.1 | 56.4% | — | — |
| GPQA Diamond | 87.0% | — | — |
| Humanity's Last Exam | 26.7% | — | — |
| RULER at 1M context | 94.7% | — | — |
Two more honest notes. First, "Codex" is not a model — it is OpenAI's coding agent product, and comparing a bare model to an agent harness is apples to oranges. The fair comparison is model versus model, and there Ultra trails the frontier flagships. Second, where Ultra genuinely wins is the combination of openness, price, and long-context agent throughput: it is the strongest model you can inspect, modify, self-host, and run at scale without a frontier API bill. It competes on value and openness. It does not beat the frontier on raw intelligence, and any article telling you otherwise is selling you something.
"5x faster": what the number actually means
NVIDIA's speed claim is real but narrow, and viral posts strip out the narrow part. The claim is roughly 5–6x higher inference throughput than comparable dense or open models at on-par accuracy on long agentic runs — NVIDIA names GLM-5.1 and Kimi K2.6 as the comparison — plus about 30% lower cost per completed agentic task, with over 300 output tokens per second on optimized Blackwell serving. Independent hoster figures back up the scale: around 460 tokens/sec at Blackbox AI, 319 at Nebius, 229 at CoreWeave.
What it is not: "5x faster than Claude" in everyday use. Throughput on a routed, shared API endpoint is a different world from dedicated Blackwell serving — OpenRouter's own live figures have shown Ultra at roughly 29–59 tokens/sec on routed endpoints, behind Opus 4.8's ~67, because routing, batching, and provider hardware dominate the real-world number. So the honest version is: on the right hardware, Ultra is exceptionally fast for an open model of its class; through a cheap shared endpoint, expect ordinary speeds. Buy the throughput story only if you control the serving stack.
Pricing: the real reason to care
If benchmarks are Ultra's weak point, pricing is its superpower. Hosted prices vary by provider, so check the listing on the day you buy — but the shape is consistent: roughly a tenth of Claude Opus 4.8's input price and a tenth of its output price.
| Route | Input / million tokens | Output / million tokens | Notes |
|---|---|---|---|
| OpenRouter | $0.50 | $2.20 | Cached input $0.10; paid endpoints list 262K context |
| NVIDIA NIM | $0.50 | $2.50 | Cached input $0.15; free developer plan available |
| Together AI | $0.60 | $3.60 | Full 1M context listed |
| Claude Opus 4.8 (for comparison) | $5.00 | $25.00 | 1M context; frontier intelligence, frontier price |
And the free routes are genuinely usable, not demos. NVIDIA's build portal gives a free API key with rate limits and no credit card. OpenCode's own Zen tier offers free rate-limited access. OpenRouter lists a free tier served by NVIDIA itself with the full 1M context and up to 65,536 output tokens — with the honest footnote that free-endpoint use is logged for security purposes and product improvement. For a freelancer or student, the free tier plus OpenCode is the whole setup: zero cost to start.
Who it is for — and who should still pay for frontier models
Ultra is for developers building agents that run long, multi-step jobs across huge codebases or document sets; for freelancers and small teams who need strong coding help without a $25-per-million-output bill; for researchers and enterprises that need inspectable weights, data provenance, and a commercial-use license; and for anyone whose workload is limited by context length or agent throughput rather than by the last few points of exam intelligence.
Still pay for a frontier flagship if your work is judged on the hardest reasoning — frontier math, the trickiest debugging, or work where a 13-point intelligence gap decides success — or if you need vision, audio, or the polished agent products (like Codex) built around closed models. The smart stack for most builders is both: Ultra for the bulk agent workload, a frontier model for the few calls that truly need it.
Setup with OpenCode, step by step
OpenCode is a free, open-source terminal coding agent: it plans, edits files, and runs commands while the model does the thinking. You need Node.js on your machine and a terminal. Install it with one command. The npm package name matters — it is opencode-ai, not opencode, and typing the shorter name gets you the wrong package or an error.
curl -fsSL https://opencode.ai/install | bash
Package-manager alternatives: npm install -g opencode-ai, Homebrew brew install opencode, Chocolatey choco install opencode. Then move into your project folder and launch it with opencode.
Route A: OpenCode Zen free key (fastest)
Inside the OpenCode TUI, run /connect, pick opencode from the provider list (shown as the Zen menu), follow the sign-in prompt, and paste the key it hands you back into the terminal. No config file, no card. Then run /models and select Nemotron 3 Ultra. Done — this is the route most readers should take first.
Route B: your own free NVIDIA key (most control)
Go to build.nvidia.com, open any model, click Get API Key, and copy it. No credit card is required. Keys start with nvapi-. Export it in your shell:
export NVIDIA_API_KEY=nvapi-YourKeyHere
Then register NVIDIA as a custom provider in ~/.config/opencode/opencode.json:
{
"$schema": "https://opencode.ai/config.json",
"provider": {
"nvidia": {
"npm": "@ai-sdk/openai-compatible",
"name": "NVIDIA NIM",
"options": {
"baseURL": "https://integrate.api.nvidia.com/v1",
"apiKey": "{env:NVIDIA_API_KEY}"
},
"models": {
"nvidia/nemotron-3-ultra-550b-a55b": {
"name": "Nemotron 3 Ultra",
"limit": { "context": 1000000, "output": 65536 }
}
}
}
}
}
Restart OpenCode (or run /reload) and select the model with /model. Two details people get wrong: the model ID must match exactly (nvidia/nemotron-3-ultra-550b-a55b), and the 1M context limit in your config only applies if your provider actually serves 1M — on capped endpoints the provider's limit wins.
Route C: OpenRouter free tier
Same config pattern, pointed at OpenRouter with your OpenRouter key, using the model ID nvidia/nemotron-3-ultra-550b-a55b (or the :free variant for NVIDIA's free endpoint). This route is useful if you want one key for many models and provider failover.
Python route and local serving
If you prefer code to a terminal agent, the NVIDIA endpoint is OpenAI-compatible, so any OpenAI client works by swapping the base URL:
from openai import OpenAI
client = OpenAI(
base_url="https://integrate.api.nvidia.com/v1",
api_key="nvapi-YourKeyHere",
)
response = client.chat.completions.create(
model="nvidia/nemotron-3-ultra-550b-a55b",
messages=[{"role": "user", "content": "Explain mixture-of-experts routing in one paragraph."}],
temperature=1,
top_p=0.95,
max_tokens=4096,
)
print(response.choices[0].message.content)
Some providers expose the model's reasoning-budget control as an extra parameter — check your provider's docs for it; if it is absent, the model still reasons by default. For local serving, NVIDIA NIM exposes the model at http://localhost:8000/v1 with vLLM, SGLang, or TensorRT-LLM backends (plus NVIDIA's Dynamo framework for disaggregated serving). Point OpenCode's NVIDIA provider at that local base URL and the same workflow runs against your own hardware.
Troubleshooting: the five failures everyone hits
| Problem | Fix |
|---|---|
| Model not listed after editing config | Restart OpenCode or run /reload — config changes do not apply to a running session |
| "Model not found" error | Check the model ID character by character: nvidia/nemotron-3-ultra-550b-a55b |
| opencode command not found after npm install | The package is opencode-ai, not opencode; check your npm global bin folder is on PATH, then reopen the terminal |
| Key errors on every call | Confirm NVIDIA_API_KEY is exported in the same shell that launches opencode, and that the key starts with nvapi- |
| Context errors on very long inputs | Your provider may cap context at 262,144 despite the model's 1M native window — check the provider listing or switch to NVIDIA's own endpoint |
System requirements: the honest version
Here is the part viral posts skip. Ultra is not runnable on a gaming PC, and pretending otherwise wastes everyone's time. The arithmetic alone says so: 550 billion parameters at 4 bits is about 275 GB of pure weights (550B x 0.5 bytes, arithmetic), and the published NVFP4 checkpoint is around 330 GB before KV cache and serving overhead, while the BF16 cache runs roughly 1.1 to 1.7 TB. A 10 GB consumer card cannot host Ultra, full stop.
| Route | What you need | Reality check |
|---|---|---|
| API / hosted (recommended for almost everyone) | Any modern PC, a terminal, Node.js, internet, a free API key | No GPU needed at all; this is how 99% of readers should use Ultra |
| Local Ultra, NVFP4 | Server-grade multi-GPU setup: minimum around 4x Blackwell GPUs or 8x H100/H200-class cards, large system RAM, fast GPU interconnect | Coverage notes 1-node is not viable and 2-node is tight; this is cluster territory |
| Local Ultra, BF16 | Roughly double the NVFP4 GPU count (e.g. 8x H200 or 16x H100 class) | Only for data centers and labs |
| Local Nano (for experimentation) | A single high-end consumer GPU (24 GB class) for the 30B model in low precision | This is the family member built for local use — start here, not with Ultra |
The takeaway: free API access is the democratization story, not local hosting. NVIDIA giving away the weights matters for enterprises, researchers, and auditability — but for an individual builder, the free key plus OpenCode delivers the model with zero hardware.
Build a 3D website in minutes: the real workflow
This is the demo everyone wants, and it genuinely works — with one catch, covered below. OpenCode plus Ultra turns a plain-language description into a working website: the agent reads your project, writes the files, installs what is needed, runs the dev server, and iterates on your feedback. A scroll-driven landing page with a glossy animated 3D object is the classic first build, using Three.js in the browser. No GPU on your machine is involved: the 3D renders in the visitor's browser, while the model only writes the code.
Copy-paste prompt template — replace the bracketed parts, paste it into OpenCode inside your project folder, and let it work:
Build a single-page landing site for [your product or idea]. Hero: a full-screen, scroll-driven section with a glossy animated 3D [object, e.g. sneaker / watch / perfume bottle] rendered with Three.js that slowly rotates and reacts to mouse movement. Below: three feature sections, a pricing strip, and a footer. Style: dark theme, modern sans-serif, generous spacing, smooth scroll animations. Use plain HTML, CSS, and JavaScript with Three.js from CDN — no build step. Then start the local dev server and tell me the URL to preview.
The build loop is: prompt, let the agent write files and start the server, open the URL in your browser, look at the result, then describe fixes back to the agent in plain language ("make the object bigger," "slow the rotation," "the pricing strip overlaps on mobile"). Each round takes minutes, and a presentable page usually lands in two to four rounds.
The honest caveat: Ultra is text-only, so it cannot see the rendered page. If the 3D object looks wrong, the lighting is off, or something overlaps on mobile, the model does not know — you are its eyes. Describe what you see precisely, or paste a screenshot description, and it will fix the code. Builders who skip the visual check ship broken pages and blame the model; builders who check each round get the "minutes, not days" result the demos promise.
Bonus: the model that won math and coding olympiads
Ultra's most interesting credential is not a benchmark table — it is two olympiad results from specialized versions of the same model. In September 2026, NVIDIA published the full recipe behind a Nemotron 3 Ultra system that scored 30 out of 42 at IMO 2026, clearing the 29-point gold threshold, with proofs written entirely in natural language — no formal prover, no external tools, no internet. The team released the specialist checkpoints, training data, code, submitted proofs, and a new 200-problem Nemotron-IMO-Bench. Separately, a fine-tuned Nemotron-3-Ultra-CC scored 535.4 out of 600 at IOI 2026, above the 361.12 gold line and the top human score of 498.27 — with the important label that the IOI run was unofficial and not part of the official ranking. These are specialist systems built on Ultra, not the base model answering questions cold — but they show what the architecture can do when aimed at one hard domain.
Frequently asked questions
Is Nemotron 3 Ultra really free?
The weights are free to download under the OpenMDW-1.1 license, and free rate-limited API routes exist (NVIDIA build key, OpenCode Zen, OpenRouter free tier). Running it yourself is not free: self-hosting needs server-grade multi-GPU hardware, and paid hosted API use is about $0.50 per million input tokens and $2.20–$2.50 per million output tokens depending on provider.
Does it really beat Claude and Codex?
No. On the Artificial Analysis Intelligence Index, Ultra scores about 48 against Claude Opus 4.8 at 61.4 and GPT-5.5 at 60.2, and on the Coding Index Opus 4.8 leads 74.3 to 49.3. Ultra wins on openness, price, and long-context agent throughput — not on raw frontier intelligence. Codex, meanwhile, is an agent product, not a model, so the comparison itself is mismatched.
Can I run it on my gaming PC?
No. The NVFP4 checkpoint alone is around 330 GB before serving overhead, and minimum local deployment is roughly 4 Blackwell GPUs or 8 H100-class cards. Use the free API route on any PC, or run the 30B Nano model locally if you want weights on your own machine.
Is the context window really 1 million tokens?
The model natively supports 1 million tokens, and NVIDIA's own endpoint serves it. But many hosted endpoints cap it at 262,144 tokens — always check your provider's listing before building a workflow that depends on 1M.
What do I need to build 3D websites with it?
OpenCode, a free API key (Zen or NVIDIA), and a browser. Paste a plain-language prompt, let the agent write the Three.js page and start a dev server, preview it yourself, and describe fixes back. Remember the model cannot see the render — you are the visual check.
Sources
- NVIDIA Nemotron 3 research page — https://research.nvidia.com/labs/nemotron/Nemotron-3/
- NVIDIA NIM reference: Nemotron 3 Ultra 550B — https://docs.api.nvidia.com/nim/reference/nvidia-nemotron-3-ultra-550b-a55b
- OpenCode providers documentation — https://opencode.ai/docs/providers/
- Artificial Analysis / OpenRouter model pages — https://openrouter.ai/nvidia/nemotron-3-ultra-550b-a55b
- Claude Opus 4.8 vs Nemotron 3 Ultra comparison — https://openrouter.ai/compare/anthropic/claude-opus-4.8/nvidia/nemotron-3-ultra-550b-a55b
- Together AI model page — https://www.together.ai/models/nvidia-nemotron-3-ultra
- Lambda model specifications — https://lambda.ai/inference-models/nvidia/nemotron-3-ultra
- IMO gold paper (arXiv:2609.10712) — https://arxiv.org/abs/2609.10712v1
- Nemotron 3 Ultra coverage and benchmarks — https://awesomeagents.ai/models/nvidia/nemotron-3-ultra-550b/
- Nemotron 3 family overview — https://www.therundown.ai/tools/nemotron-3
Be the first to share a useful question or thought.