Nemotron 3.5 Bolt and Super VL: which one runs on your GPU

NVIDIA's 3 new Nemotron 3.5 models cover 3 sizes of machine. Bolt E4B's 4-bit file is 6.2 GB, so it fits an 8 GB card. Bolt 74B-A9B was built to fit a 24 GB card and runs comfortably on a 32 GB RTX 5090 or a DGX Spark. Super VL needs about 70 GB at 4-bit, so 1 DGX Spark, 1 RTX PRO 6000 or 1 H200. Super VL and Bolt 74B came out on 19 October 2026; Bolt E4B's weights went public on Hugging Face on 23 October.

Which one fits the machine you have

The memory figures come from our GPU memory calculator, which reads each model's own files on Hugging Face, with an 8-bit KV cacheKV CacheWork a model saves from the text it has already read, so it is not redone for every new token. Prompt caching keeps that work between requests and charges less for it., as NVIDIA's Bolt recipe uses. They match the machines NVIDIA lists on its model cards.

Bolt 74B-A9B: a 74B model in 24 GB

A 74-billion-parameter model would need about 42 GB in a usual 4-bit format, by our calculator. NVIDIA got Bolt into 24.1 GB in 2 steps.

First it cut Super VL down. Its Star Elastic method let a router choose, layer by layer, how many experts to keep and how wide each is, with a fixed budget: under 24 GB with 1 conversation of 128K tokens. Each token now uses 9 experts instead of Super VL's 22, so 9B of the 74B parameters work on each token, a mixture of expertsMixture of ExpertsA neural architecture that routes tokens through different expert subnetworks. made leaner. The cut model was then trained against the full one to win back accuracy, a form of distillationKnowledge DistillationTraining a small "student" model to copy the outputs of a large "teacher" model, so the small one keeps much of the large one's skill at a fraction of the cost to run..

Then it squeezed the numbers. The experts, most of the weights, are stored at 2.06 bits each (IQ2_XXS, a llama.cpp format). The Mamba layers are kept at 4-bit and the embedding and output layers at 8-bit, and the model was trained in that form so it would not lose accuracy to it. That is QuantizationQuantizationStoring a model's numbers with less precision, such as 4 bits instead of 16, so it needs far less memory and can run on smaller hardware, at some cost in accuracy. pushed much further than the usual 4-bit, done by NVIDIA itself rather than by someone converting the weights afterwards.

The context costs little. Of the 48 layers that keep anything between tokens, 40 are Mamba-2 layers with a fixed state; only 8 are attention layers whose cache grows (see state space modelsState Space ModelA layer that reads text in order and carries a fixed-size summary forward instead of keeping every past token, so its memory stays the same however long the conversation gets. Mamba is the best-known kind.). For 1 conversation of 128K tokens the calculator puts its cache at 0.7 GB with an 8-bit cache. Llama 3.3 70B, a plain Transformer of about the same size, needs 21.5 GB for the same conversation.

The hardware catch

The 24GB release's card gives Blackwell SM120 and SM121 as the supported hardware, the chips of the RTX 50 series, RTX PRO Blackwell cards and DGX Spark, and says NVIDIA cut the experts to 2 bits to fit RTX Spark's memory. Its vLLM deployment line also names A100 and H100-80GB, and the recipe downloads extra kernels first. An RTX 4090 or 3090 is not named. For those, NVIDIA publishes a GGUF build for llama.cpp: a 22.0 GB model file plus a 1.7 GB file for images. That is a tight squeeze on a 24 GB card with a desktop running beside it, so expect to keep the context short there.

On speed, the calculator's ceiling for 1 conversation is about 560 tokens a second on an RTX 5090 and 85 on a DGX Spark, from each one's memory bandwidth. Real runs reach part of that. NVIDIA's recipes add a LiLiCorr drafter for speculative decodingSpeculative DecodingA small, fast drafter guesses the next few tokens and the large model checks them all in one pass, keeping the ones it agrees with. Answers come faster and stay exactly the same., which helps most in exactly this case of one person waiting for one answer. NVIDIA does not publish the RTX Spark's memory bandwidth, so we cannot give a ceiling for it.

What NVIDIA's benchmarks show

NVIDIA compares the 2-bit Bolt with 3 models of similar memory use, run at 16-bit:

It leads on these agent and reasoning tests. It is behind Qwen and NVIDIA's own Lightning on not making things up when it does not know, so ground it with search or documents for factual work. These are NVIDIA's own runs.

Super VL: the full model, now reading images and video

Super VL is the parent: 120B parameters, 12B active per token, text, images and video in, and a context of up to 1 million tokens. Its language backbone starts from Nemotron 3 Super Base. Next to Nemotron 3 Super, which was text-only with a 262K context in our calculator at almost the same size, it adds vision and 4 times the context.

At 16-bit it is 249 GB, so 4 H100s or 2 GB200s, which is what NVIDIA lists. NVIDIA's 4-bit NVFP4 release is about 70 GB, which fits 1 DGX Spark, 1 RTX PRO 6000, 1 H200 or 2 H100s with the full 1M context, as NVIDIA's card says and the calculator agrees. Its built-in multi-token prediction head gives it speculative decoding with no second model.

On NVIDIA's benchmark table it is a strong model, not the strongest open one. It scores 71.1 on SWE-bench Verified, against 78.7 for Qwen3.8-Flash-Next and 79.1 for GLM-5.3-Flash, and 60.7 on Terminal-Bench 2.1 against Qwen's 85.8. It is more cautious than most models in the table. In AA-Omniscience, when it does not know an answer it guesses wrong 30% of the time instead of saying so, against 84.5% for Qwen3.5-122B-A10B and 22.1% for Nemotron 3 Ultra. If you want the best open coding model, this is not it. If you want one that reads documents and screens and says when it does not know, it is worth a test.

Bolt E4B: the small one, out today

Bolt E4B is a different kind of model. NVIDIA took Google's Gemma 4 E4B and post-trained it for fast local assistants: voice and device assistants, interactive characters, and embedded interfaces such as a robot's. It is a small language modelSmall Language ModelA language model small enough to run on a laptop, phone, robot or single GPU, usually a few billion parameters, trading some broad knowledge for speed, low memory and privacy. with 8B parameters stored and 4B effective, text in and text out, and a 64K-token context.

Memory is not the question here. The 4-bit Q4_K_M file is 6.2 GB, and the calculator puts the weights at 4.5 GB at 4-bit, plus 0.3 GB for a 32K conversation and 0.5 GB at its full 64K, with an 8-bit cache. Its cache is tiny because 18 of its 42 layers reuse the cache of earlier ones and most of the rest keep only the last 512 tokens. NVIDIA says it runs in about 4 GB in its target workloads and shows it on a Jetson Orin Nano 8GB.

Against other 4B models in NVIDIA's tables, it follows instructions far better, with 84.8 on IHEval against 60.6 for Qwen3.5 4B, and stays in character better. Qwen3.5 4B beats it on multi-turn customer tasks (Tau2-Bench 75.1 against 55.1) and on long-context retrieval (RULER 95.1 against 87.0). So use it where speed, short answers and obeying the rules matter, and not to read long documents.

Which to pick

• A chat or voice assistant, an interactive character, a robot: Bolt E4B. It leaves the rest of the GPU free for speech, vision or your app.
• A local coding or research agent on a 32 GB card or a Spark: Bolt 74B-A9B 24GB. Check your card is Blackwell first, or use the GGUF build.
• Documents, screenshots and video with long context on 1 big machine: Super VL at 4-bit.
• Already on Nemotron 3 Super: Super VL is almost the same size and adds vision and 4 times the context. Rerun your own tests before you switch.

All 3 are under OpenMDW-1.1, which allows commercial use; E4B also carries Gemma 4's Apache 2.0 terms. To work out another context length or GPU, open each model's page in the calculator, or read how much VRAM you need to run an LLM locally for the method behind the numbers. For serving them, vLLM or Ollama is the next choice.