What Is NVIDIA Nemotron? Every Model Explained (3 Nano, Super, Ultra, 3.5 Lightning, Super VL, Bolt), Which to Run, Ollama Names and Licenses

NVIDIA Nemotron is NVIDIA's family of open AI models: you can download the weights free, run them on your own GPU or server, and use them commercially. The current models are the Nemotron 3 generation (Nano 30B with 3B active, a Nano 4B, Nano Omni for audio and video, Super 120B with 12B active, and Ultra 550B with 55B active) and the newer Nemotron 3.5 generation (Lightning 30B, Super VL 120B with vision, Bolt 74B in a 24 GB file for AI PCs, the small Bolt E4B due in late October 2026, and a 0.6B speech recognition model). All of them use a hybrid design that mixes Mamba-2 layers with Transformer attention and mixture-of-experts layers, which makes them fast on long inputs, and most handle up to a million tokens of context. Which one to run depends on your memory: about 5 GB for Nano 4B, 20 to 25 GB for Lightning, 25 GB for Bolt, 64 GB or more for Super VL, and a rack of data-center GPUs for Ultra. Below: every model in one table, which to pick for your hardware, how to run each one in Ollama, licenses, and how Nemotron compares with Llama, Qwen and DeepSeek.

Ethan asked Jake which Nemotron to install, and Jake opened Ollama's model list to check. There were ten entries with "nemotron" in the name, three of them cloud-only, two of them older Llama-based models, and version numbers 3, 3.5 and none at all. Picking the right one took longer than downloading it, which is why this page exists.

New to running models on your own computer? The cards below cover the two newest Nemotron models in depth, choosing a runner, and the hardware question.

What NVIDIA Nemotron is, in plain English

NVIDIA is best known for the GPUs that AI runs on. Nemotron is its own line of AI models, released as open weights: the trained model files are on Hugging Face, so you can download them, run them offline, fine-tune them on your data, and build products on them. NVIDIA also publishes much of the training data and recipes, which is rarer.

Why does a chip company make models? Partly to show what its hardware can do (the models are tuned for NVIDIA's 4-bit NVFP4 format on Blackwell GPUs), and partly for AI agents: every recent Nemotron release is pitched at tool calling, multistep reasoning and long documents, the things an agent spends its time on. You can use them in three ways:

• On your own machine, through Ollama, LM Studio or llama.cpp, for free.
• On your own servers or cloud GPUs, with vLLM, SGLang, TensorRT-LLM or NVIDIA NIM containers.
• As an API, through NVIDIA's build.nvidia.com, OpenRouter, Ollama's cloud models and other hosts, paying per token.

Most models have a thinking switch: reasoning is on by default, and you turn it off in the chat template (enable_thinking=False) when you want short, fast answers.

Jake: "So it's like Llama, but from NVIDIA?"

Ethan: "Same idea, open weights you can run yourself. The insides are different, which is why it's quick on long inputs."

Every Nemotron model in one table

Two naming rules make the list easier. "A" numbers are active parameters: 120B-A12B means 120 billion in total but only 12 billion used for each token, so it runs at the speed of a much smaller model while needing the memory of the big one. And 3.5 replaces 3 where both exist: 3.5 Lightning is the newer version of the 30B Nano size, and 3.5 Super VL the newer 120B with vision added.

Why Nemotron is fast: the Mamba-Transformer hybrid

Most chat models are pure Transformers. Their attention layers compare every token with every earlier token, so the work and the memory for the context (the KV cache) grow with the length of your input. Nemotron 3 and 3.5 replace most of those layers with Mamba-2 layers, which carry a fixed-size summary of what came before instead of looking back at everything. A few attention layers remain for the precise lookups Mamba is weaker at.

On top, most models use mixture of experts (NVIDIA's variant is called LatentMoE): many small expert networks, of which only a few run for each token. Super and Ultra add multi-token prediction, which drafts several tokens at once to speed up generation. The practical results for you:

• Long inputs are cheap: up to 1M tokens of context on most models, and much less memory per extra token than a pure Transformer.
• High speed for the size: a 30B-A3B model generates like a 3B model.
• Some tools lag behind: a new hybrid needs runtime support, so check that your Ollama, LM Studio or llama.cpp version is recent before you report a "broken model".

The Nemotron 3 family

Nemotron 3 Nano (30B-A3B) opened the generation in December 2025: 30 billion parameters with about 3.5 billion active, 52 layers (23 Mamba-2, 23 MoE with 128 experts each, and 6 attention layers), up to 1M tokens, and six languages (English, German, Spanish, French, Italian, Japanese). It became a popular local model because it fits a 24 to 32 GB GPU once quantized and answers quickly.

Nemotron 3 Nano 4B is the edge version: a 4 billion parameter hybrid model compressed and distilled from Nemotron Nano 9B v2, for Jetson boards, laptops and small GeForce cards, in about 5 GB of memory. Nemotron 3 Nano Omni is the multimodal Nano: one model that understands text, images, audio and video, listed in Ollama as nemotron3.

Nemotron 3 Super (120B-A12B), from March 11, 2026, is the mid-size reasoning model: 120 billion parameters with 12 billion active, LatentMoE and multi-token prediction, up to 1M tokens, and seven languages including Chinese. In BF16 it needs eight H100 80 GB GPUs; the NVFP4 version fits a single B200 or a DGX Spark. It has a low-effort reasoning mode for cheaper answers.

Nemotron 3 Super review: benchmarks and where it is strong

Nemotron 3 Super is the most used model in the family, with millions of pulls of the Ollama cloud version alone, so it deserves a closer look. Its launch scores against the two models people usually compare it with, both open mixture-of-experts models of a similar size:

The honest review: Super is not the top scorer on most rows, and Qwen3.5-122B beats it on knowledge, science, software engineering and agent benchmarks. Where it stands out is long context (it holds up at a million tokens, where GPT-OSS-120B collapses), math with tools, and throughput: the Mamba hybrid and multi-token prediction make it fast and cheap to serve for its size, which is why it is popular behind agents that read long documents. It is text only; for images and video, use 3.5 Super VL.

Jake: "So Qwen wins the scoreboard but people still pick Super?"

Ethan: "For million-token documents and cheap serving, yes. Pick by the job, not the leaderboard."

Nemotron 3 Ultra: the 550B flagship

Nemotron 3 Ultra (550B-A55B), released June 4, 2026, is the largest Nemotron: 550 billion parameters with 55 billion active, the same Mamba-2, MoE and attention hybrid with multi-token prediction, up to 1M tokens, and ten languages (English, French, Spanish, Italian, German, Japanese, Hindi, Korean, Brazilian Portuguese and Chinese). It targets complex agent workflows, long-context analysis and high-stakes reasoning, with an on/off thinking switch and a medium-effort mode that spends fewer reasoning tokens.

It is a data-center model. The BF16 weights need eight GB200, B200, GB300 or B300 GPUs, eight H200s or sixteen H100s; an NVFP4 version halves that footprint but is still far beyond a PC. For most people, Ultra is something you call as an API (NVIDIA's API catalog, OpenRouter or the Ollama cloud model nemotron-3-ultra) rather than download. It is licensed under OpenMDW 1.1, which allows commercial use.

Who should use Ultra? Teams that need the strongest open model they can host themselves for compliance reasons, and anyone who wants an open-weight alternative to closed frontier APIs for hard analysis, where the per-token price of a hosted Ultra is lower than the top closed models. For everyday chat, coding help or document extraction, Super or the 3.5 models give most of the quality at a fraction of the cost.

Jake: "Can my 5090 run Ultra if I quantize it hard enough?"

Ethan: "550 billion parameters at 2 bits is still well over 130 GB. That's what Bolt is for."

The Nemotron 3.5 family

Nemotron 3.5 Lightning (30B-A3B), generally available since August 11, 2026, is the fast text model of the new generation: 30 billion parameters, 3 billion active, Mamba-2 and MoE layers with some attention plus multi-token prediction, up to 1M tokens, licensed under OpenMDW 1.1. It reads English, code, Spanish, French, German, Italian and Japanese, needs about 20 GB of memory at 4-bit, and comes with draft models for speculative decoding. On a 24 or 32 GB card with no need for images, it is the default pick.

Nemotron 3.5 Super VL (120B-A12B), released October 15, 2026, keeps Super's size and adds vision: it reads screenshots, documents, charts and short videos, for document AI and computer-use agents. Our Super VL guide covers memory, Ollama, LM Studio and the API price.

Nemotron 3.5 Bolt (74B-A9B), from the same launch, is Super VL compressed for one GPU: fewer experts per token (9 instead of 22) and trained to run at about 2 bits per expert weight, so the whole model is a 24 GB file. It reads images and video, and NVIDIA built it for agents on RTX Spark AI PCs and DGX Spark. Our Bolt guide has VRAM by GPU and the llama.cpp recipe. Bolt E4B, a much smaller sibling of about 4 GB for voice assistants and game characters, is due later in October.

Nemotron 3.5 ASR Streaming 0.6B is a speech-to-text model, not a chat model: 600 million parameters, a cache-aware FastConformer encoder with an RNN-T decoder, 40 language and locale combinations in one checkpoint, and chunk sizes from 80 ms to 1.12 seconds for live captions and voice agents. Set the language explicitly when you call it; an empty language prompt is a known cause of errors.

Which Nemotron to run on your hardware

1. 8 GB GPU or a thin laptop: Nemotron 3 Nano 4B now, or wait a few days for Bolt E4B.
2. 16 GB: Nano 4B at higher precision. Lightning's 2-bit GGUF can work with a short context if you accept some quality loss; at 4-bit it wants about 20 GB.
3. 24 GB (RTX 3090, 4090): 3.5 Lightning for text. Bolt's 24 GB file leaves too little room for context on a 24 GB card.
4. 32 GB (RTX 5090): Bolt if you want vision, Lightning for faster text with long context.
5. 48 GB and up, or a 128 GB RTX Spark or DGX Spark: Bolt with full context, or Super VL quantized.
6. Servers with several data-center GPUs: Super VL in BF16 or NVFP4, or Ultra.
7. Just need answers, no hardware: use the API versions (Ultra and Super through NVIDIA's catalog, OpenRouter or Ollama cloud).

Remember that the model file is only part of the memory: context (the KV cache) and, for vision models, the image encoder need room too. If Ollama stops with a "requires more system memory" error, our memory error guide shows how to shrink the context. On a Mac, check the model page first: Bolt in Ollama does not support Apple Silicon yet, while Lightning has an MLX build.

Nemotron in Ollama: downloads vs cloud models

Ollama's library mixes downloadable models with cloud-only listings, which is where most confusion starts:

ollama run nemotron-3.5-lightning
ollama run nemotron-3.5-bolt
ollama run nemotron3
ollama ps

ollama ps shows whether the model sits on your GPU or spilled into system memory; if it says CPU, our GPU fix guide helps. Hybrid models need a current Ollama, so update Ollama first if a pull fails with an unknown architecture error. For LM Studio and llama.cpp, Unsloth publishes GGUF files, for example unsloth/NVIDIA-Nemotron-3.5-Lightning-30B-A3B-GGUF.

Download Nemotron from Hugging Face

Every model lives under the nvidia organization on Hugging Face, usually with BF16 weights for fine-tuning and lower-precision versions (FP8 or NVFP4) for serving. The main repositories:

• nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B-BF16
• nvidia/NVIDIA-Nemotron-3-Super-120B-A12B-BF16, with an NVFP4 version for a single B200 or a DGX Spark
• nvidia/NVIDIA-Nemotron-3-Ultra-550B-A55B-BF16, with an NVFP4 version
• nvidia/NVIDIA-Nemotron-3.5-Lightning-30B-A3B-NVFP4
• nvidia/NVIDIA-Nemotron-3.5-Bolt-74B-A9B-24GB-GGUF, the ready-to-run local build
• nvidia/nemotron-3.5-asr-streaming-0.6b for speech recognition

pip install -U huggingface_hub
hf download nvidia/NVIDIA-Nemotron-3.5-Lightning-30B-A3B-NVFP4 --local-dir ./lightning

For desktop apps you rarely need these raw repositories: Ollama, LM Studio and Unsloth's GGUF uploads package the same models ready to run. The raw weights matter when you serve with vLLM, SGLang or TensorRT-LLM, or when you fine-tune. Check free disk space first: BF16 weights take about 2 bytes per parameter, so Super is roughly 240 GB and Ultra over a terabyte.

Serving Nemotron with vLLM for a team

To run Nemotron as a shared, OpenAI-compatible endpoint, vLLM is the usual choice. The launch command for Nemotron 3 Super on an eight-GPU server shows the settings that matter for this family:

vllm serve nvidia/NVIDIA-Nemotron-3-Super-120B-A12B-BF16 \
  --served-model-name nvidia/nemotron-3-super \
  --dtype auto --kv-cache-dtype fp8 \
  --tensor-parallel-size 8 --enable-expert-parallel \
  --max-model-len 262144 --trust-remote-code \
  --mamba-ssm-cache-dtype float32 \
  --reasoning-parser nemotron_v3 \
  --enable-auto-tool-choice --tool-call-parser qwen3_coder

• --reasoning-parser nemotron_v3 separates the thinking from the answer, so clients get clean content.
• --tool-call-parser qwen3_coder with --enable-auto-tool-choice turns the model's tool-call format into standard tool_calls.
• --mamba-ssm-cache-dtype float32 keeps the Mamba state at full precision, which these hybrids need for quality.
• --max-model-len sets the context; 262,144 is the default config, and you can raise it toward 1M if memory allows.

On B200 or B300 GPUs the BF16 Super checkpoint fits on two cards instead of eight. SGLang and TensorRT-LLM work too, with the same parsers under their own flag names. Keep the sampling at temperature 1.0 and top_p 0.95, the values NVIDIA uses for every task.

Use Nemotron through an API (NVIDIA, OpenRouter, Ollama cloud)

If you have no GPU, three hosted routes speak the OpenAI API format:

1. NVIDIA's API catalog: sign in at build.nvidia.com, create a key under your account's API keys (it starts with nvapi-), and call https://integrate.api.nvidia.com/v1. Nemotron models are available there for prototyping; check your account page for current limits.
2. OpenRouter: one key for many providers, with per-token prices and, for some models, a rate-limited :free variant.
3. Ollama cloud models: nemotron-3-nano, nemotron-3-super and nemotron-3-ultra run on Ollama's servers from the same ollama run command, billed per token.

import os
from openai import OpenAI

client = OpenAI(base_url="https://integrate.api.nvidia.com/v1", api_key=os.environ["NVIDIA_API_KEY"])
reply = client.chat.completions.create(
    model="MODEL-NAME-FROM-THE-CATALOG-PAGE",   # copy it from the model's page on build.nvidia.com
    messages=[{"role": "user", "content": "Summarize the Mamba-Transformer hybrid in two sentences."}],
    temperature=1.0, top_p=0.95,
)
print(reply.choices[0].message.content)

Keep these keys out of your code like any other; our API key guide covers storage, leaks and spend limits, and the same rules apply to nvapi- keys.

Nemotron on AWS: Amazon Bedrock and SageMaker

Four NVIDIA models are on Amazon Bedrock as serverless, pay-per-token models, so you can call them with boto3 and IAM instead of running GPUs:

• Nemotron Nano 9B v2: text generation, reasoning and coding.
• Nemotron Nano 12B v2 VL: vision-language, for image understanding and visual Q&A.
• Nemotron 3 Nano 30B: the 30B-A3B reasoning and coding model.
• Nemotron 3 Super 120B: 120B with 12B active and a 1M-token context, aimed at multi-agent applications.

Copy the exact model ID from the Bedrock model catalog in your Region (availability varies by Region), then call it with the Converse API, which works the same across Bedrock models; our Converse API guide has the code. The 3.5 models are not on Bedrock yet; Super VL can be deployed from SageMaker AI JumpStart on your own endpoint, and Bolt runs on a g6e GPU instance, as our Super VL and Bolt guides show.

Nemotron Nano 2: the 9B and 12B VL models

Before Nemotron 3, the Nemotron Nano 2 generation (2025) brought the hybrid design to small models. Nemotron Nano 9B v2 is a 9 billion parameter text model for reasoning and coding, and Nemotron Nano 12B v2 VL adds vision for documents, charts and images. Both are still useful where they are already deployed, and both are on Amazon Bedrock. For new local projects, Nemotron 3 Nano 4B (distilled from Nano 9B v2) and 3.5 Lightning are the newer options at similar or better efficiency, and 3.5 Bolt replaces the 12B VL model when you have the memory for it.

Where Nano 2 still makes sense: a serverless Bedrock workload that needs a cheap, small text or vision model today, with no GPU to manage. The 12B VL model in particular is one of the few small vision-language models available serverless on AWS, which makes it a reasonable choice for reading receipts or product photos at volume. If you started on it, moving to Nemotron 3 Nano 30B on Bedrock is the natural upgrade for text; for vision, wait for a 3.5 vision model on Bedrock or host Bolt yourself.

Jake: "Our receipts pipeline runs on the 12B VL model on Bedrock. Should we switch?"

Ethan: "If it's accurate enough, no rush. Test Bolt on a hundred hard receipts first and switch only if it wins clearly."

Nemotron 3 Nano and Nano 4B in practice

Nano 30B-A3B is the workhorse: 30 billion parameters but only about 3.5 billion active, so it generates at small-model speed on one GPU. In Ollama, the nemotron-3-nano entries are cloud models; to run it on your own machine, use a GGUF build from Unsloth or another uploader in LM Studio or llama.cpp (search Hugging Face for "Nemotron-3-Nano-30B-A3B-GGUF"), or its newer replacement, nemotron-3.5-lightning, which is a download in Ollama. At 4-bit, plan on about 20 GB of memory plus context.

Nano 4B is the one for small hardware: Jetson Thor and Orin Nano boards, laptops and 8 GB cards, in about 5 GB of memory with the same hybrid design and up to 1M tokens of context. It works with Transformers, vLLM, TensorRT-LLM and llama.cpp. Expect it to handle classification, extraction, short chat and simple tool calls well, and to need a larger model for multistep reasoning.

Both have the thinking switch, and for Nano-class models it matters more than usual: with thinking off, they answer in a fraction of the time, which is often the right trade for routing, tagging or summarizing at volume.

Nemotron 3 Nano Omni: audio, video, images and text

Nano Omni is the multimodal member of the Nemotron 3 family: one model that understands video, audio, images and text, listed in Ollama as nemotron3 with a 21 to 28 GB download and a 128K context there, plus an MLX build for Macs. Typical uses are the ones that would otherwise need two or three models chained together: summarizing a recorded meeting from its audio, answering questions about a screen recording, or describing what happens in a short clip. Its license is the NVIDIA Open Model Agreement, which allows commercial use. For pure speech-to-text at low latency, the dedicated 0.6B ASR model is lighter and faster; Omni is for when you need understanding, not just transcription.

Nemotron 3.5 Lightning in detail

Lightning is the model most people with a single 24 or 32 GB GPU should try first, so a few details beyond the table:

• Speed tricks built in: it has multi-token prediction layers and ships with separate draft models (DSpark and DFlash) for speculative decoding, so runtimes that support them can generate several tokens per step.
• Hardware: the NVFP4 checkpoint targets Blackwell GPUs (GB200, DGX Spark, with RTX 5090 support listed as still to be confirmed). On Hopper (H100, H200) and Ampere (A100) it runs with 4-bit weight kernels instead, since those GPUs lack FP4 hardware. On consumer cards, GGUF builds in Ollama or LM Studio are the simple route.
• Settings: temperature 1.0 and top_p 0.95 in NVIDIA's recommendations; thinking is on by default and turned off with enable_thinking set to false. For coding agents, the model card adds force_nonempty_content so a reply always contains content, not only reasoning.
• Languages: English and code first, plus Spanish, French, German, Italian and Japanese.

Think of Lightning as the fast text worker: summaries, extraction, code completion and agent steps that do not need images, at 3B-active speed with a context long enough for whole repositories.

Nemotron 3.5 ASR: speech to text in real time

The speech model is easy to overlook in a family of chat models, but it fills a real gap: live transcription on modest hardware. At 600 million parameters it runs comfortably on a laptop GPU, and its cache-aware streaming design returns final text in well under a second. Ways to use it:

• NVIDIA NeMo (version 26.06 or later) for Python pipelines and fine-tuning on your own accents or vocabulary.
• Hugging Face Transformers for quick experiments.
• A GGUF build for NeMo-Speech.cpp for lightweight local apps.
• Hosted APIs such as Together AI if you prefer not to run it yourself.

Choose the chunk size by what you are building: 80 ms or 160 ms for voice agents that must react quickly, 560 ms or 1.12 seconds for captions and meeting notes, where slightly later but steadier text reads better. One checkpoint covers 40 language and locale combinations, steered by a language prompt; set the language explicitly in your call, since leaving it empty is a known source of errors. Pair it with a chat model such as Lightning (or Bolt E4B when it arrives) and you have a fully local voice assistant.

Jake: "We pay per minute for meeting transcription. Could this replace it?"

Ethan: "For English and the big languages, very likely. Run a week of recordings through both and compare the errors."

NVIDIA's own hardware for Nemotron: RTX Spark and DGX Spark

NVIDIA designs the newest Nemotron releases with its own desktop hardware in mind. DGX Spark is a small desktop with 128 GB of unified memory that runs Super in NVFP4 or Bolt with its full context. RTX Spark laptops, on sale since October 16, 2026 from Acer, ASUS, Dell, HP, Lenovo, Microsoft, MSI and Gigabyte, pair a Blackwell GPU with a Grace CPU and up to 128 GB of unified memory; Bolt was built to run agents on exactly these machines. Ordinary RTX 40 and 50 series cards run the smaller models well, as the hardware list above shows. Our local LLM laptop guide compares these machines with Macs and gaming laptops.

Tool calling and agents with Nemotron

Every current Nemotron chat model supports OpenAI-style tool calls, and the family is tuned for agent work, so the details are worth getting right:

• Ollama: pass tools in the chat request; models marked "tools" in the library handle it natively.
• llama.cpp: start llama-server with --jinja so the model's own chat template formats tool calls.
• vLLM: --enable-auto-tool-choice --tool-call-parser qwen3_coder, as in the serve command above.
• Reasoning in agent loops: full thinking on every step is slow; use the low or medium effort modes where the model offers them, and full thinking only for planning steps.

Our Bolt guide walks through a complete Python tool-calling loop that works with any of these models, plus how to plug them into coding agents such as OpenCode.

Which Nemotron for which job

Fine-tuning Nemotron on your own data

Open weights mean you can adapt Nemotron to your task, and the Kaggle challenge above showed how far a small adapter can go. Practical starting points:

1. Start from the BF16 weights, not the NVFP4 or GGUF builds, which are for serving.
2. Pick the smallest model that could work: LoRA on Nano 30B needs the BF16 base loaded (about 60 GB), which fits one 80 GB GPU; Super and Ultra need multi-GPU servers.
3. Use NVIDIA's tooling or a trainer that supports the hybrid architecture: NeMo and its recipes are built for these models, and NVIDIA's released post-training data shows the expected data format.
4. Keep a held-out test set of real examples and compare the adapter against the base model with thinking on and off; often a better prompt closes most of the gap.
5. Serve the adapter with vLLM's LoRA support, or merge it and re-quantize for local apps.

Is Nemotron open source? Weights, data and the technical report

More open than most. NVIDIA releases the weights under open licenses, and also large parts of the training data and the recipes:

• Pre-training data: major portions are published in the Nemotron Pre-Training Datasets collection on Hugging Face; Nemotron 3 Super was pre-trained on about 25 trillion tokens.
• Post-training data: the fine-tuning corpus is largely in the Nemotron Post-Training v3 collection.
• Reinforcement learning: environments and datasets are in NeMo Gym on GitHub.
• Access: a sample set is open to all; code, math and multilingual sets need a short approval, and some third-party data could not be released.

The Nemotron 3 technical report, "NVIDIA Nemotron 3: Efficient and Open Intelligence", is on arXiv (2512.20856), and the Super technical report is a PDF on NVIDIA Research's Nemotron site. They are the documents to read if you want the architecture details, the data mix and the training recipe rather than the summary here. Strictly speaking, "open source" fits the code and data; the weights are "open weights" under the licenses below.

The NVIDIA Nemotron Model Reasoning Challenge

From March to June 2026, NVIDIA ran a Kaggle competition built on Nemotron 3 Nano 30B-A3B. Teams had to raise the model's accuracy on a new set of logic puzzles, but the base model was fixed: every entry was a LoRA adapter of rank 32 or lower, run with fixed inference code and no internet access on identical Google Cloud machines with RTX PRO 6000 Blackwell GPUs. More than 5,000 people in about 4,000 teams took part, and NVIDIA published a retrospective in July on what the top teams did.

The takeaway for everyone else: a small, cheap adapter on an open model can move reasoning scores a long way, which is the practical case for fine-tuning Nano-class models on your own task instead of paying for a bigger one.

Nemotron licenses: can you use it commercially?

Yes, for every current model, but two licenses are in play. The Nemotron 3 Nano and Super checkpoints use the NVIDIA Nemotron Open Model License, which allows commercial use under NVIDIA's terms. Nemotron 3 Ultra and the 3.5 models (Lightning, Super VL, Bolt, ASR) use OpenMDW 1.1, a permissive license that also covers commercial and non-commercial use. Read the license on the model card of the exact checkpoint you ship, since quantized community files inherit the original terms.

Before you build a product or a paid service on a Nemotron model, a short checklist saves trouble later:

1. Write down the exact checkpoint (for example NVIDIA-Nemotron-3.5-Lightning-30B-A3B-NVFP4), not just "Nemotron".
2. Open its model card on Hugging Face and save the license text that applies to that checkpoint.
3. Check the quantized file's source: a GGUF from Unsloth or another uploader carries the original license, so trace it back to the original nvidia/ repository.
4. Keep the license file with your release and follow any notice requirements in it.
5. Recheck when you upgrade: moving from a Nemotron 3 model to a 3.5 model changes the license from the Nemotron Open Model License to OpenMDW 1.1.

Nemotron vs Llama, Qwen and DeepSeek

• Speed on long inputs: Nemotron's Mamba hybrid holds up better than pure Transformers as context grows, and NVFP4 builds run especially well on Blackwell GPUs.
• Openness: NVIDIA releases weights plus much of the training data and recipes, more than most labs.
• Range: Qwen and Llama have more sizes and more community fine-tunes; Nemotron is newer and its tooling occasionally lags.
• Top-end quality: Ultra is among the strongest US open-weight models, while the largest DeepSeek and Qwen models still lead on some reasoning benchmarks. Test on your own tasks.
• Hardware fit: Bolt's 24 GB file and Lightning's 3B active parameters make Nemotron one of the better families for single-GPU agents.

If you are still choosing a runner, our Ollama vs LM Studio comparison helps, and for agents that run code, NVIDIA's OpenShell sandbox keeps them contained.

Older Nemotron models you will still see

Before the Nemotron 3 hybrids, the name covered different kinds of models. Nemotron-4 340B (2024) was a large Transformer often used to generate training data. The Llama-Nemotron models, such as Llama 3.1 Nemotron 70B (Ollama's plain nemotron), were Meta Llama models post-trained by NVIDIA. Nemotron Nano 9B v2 (2025) was an earlier small hybrid that Nano 4B was distilled from, and nemotron-mini is a 4B model for simple tasks. They still work, but for anything new, the 3 and 3.5 models are better at the same size.

That history explains a common mix-up. A tutorial from 2024 that says "run Nemotron" usually means the Llama-based 70B, a pure Transformer with a 128K context and no thinking switch. A 2026 guide means the hybrid generation. If a command or a benchmark looks wrong for your model, check which generation the author was using before you change anything.

Frequently asked questions

Jake settled on Lightning for his coding agent, where speed and long context mattered, and Bolt for the one job that needed screenshots, with Ultra through an API for the occasional hard question. Three Nemotrons, each in the place it fits, picked from the memory he had rather than the biggest number on the list.

Revision note. Written October 20, 2026. NVIDIA releases Nemotron models often; this page will get dated updates as new ones arrive.