NVIDIA Nemotron 3.5 Bolt vs. Super VL: Hands-On Review

Running a model with 74 billion total parameters on a laptop and watching it generate at 65.5 tokens per second is one of those experiences that makes the local-AI conversation suddenly feel very real.

That is the high point of my first few days with NVIDIA Nemotron 3.5 Bolt 74B-A9B, and I don't want the details of benchmark scoring to obscure it. I can run a remarkably capable model on my own machine, at interactive speeds, without sending the inference workload to a remote provider. For people building personal assistants, experimenting with local agents, or simply wanting more control over their AI setup, this is a meaningful step forward.

I also tested Nemotron 3.5 Super VL, a larger, vision-language-focused sibling, through OpenRouter Chat. Both models answered my basic logic and business-analysis questions well. Super VL was particularly effective in a tool-assisted historical fact-check and made a more successful first pass at producing a playable game.

But NVIDIA did not build these models to win my improvised dungeon-crawler contest. The company's pitch is more interesting: a family of open, customizable models for agents, spanning local desktops and more demanding multimodal deployments. The question is which tool belongs in which workflow.

What NVIDIA Actually Released
My Test Setup: Two Very Different Ways to Run AI
What Bolt Was Like to Use Locally
The Surprising Cost of Precise Instructions
A Fact-Check That Revealed a Real Difference
Coding: Encouraging, With a Big Testing Qualification
Where I'd Reach for Each Model
What I Would Watch Next
Verdict
Related Articles From The Neuron
Where to Try Them

What NVIDIA Actually Released

NVIDIA announced the models on October 15, positioning Super VL for specialized, always-on multimodal agents and Bolt for agentic work on local NVIDIA hardware. A still-smaller Bolt E4B model, designed around a 4GB footprint, is slated for October 23. NVIDIA also offers Lightning for high-throughput work and Ultra for its most demanding reasoning tier.

Bolt 74B-A9B has 74 billion total parameters, with roughly 9 billion active per token, in a mixture-of-experts (MoE) architecture. The 24GB release relies on native 2-bit quantization and quantization-aware techniques designed to keep useful capability while lowering memory demands. Its advertised target is everyday local agents that can search, use tools, and write or debug code. NVIDIA says it is designed to fit in 24GB alongside other applications.

Super VL has 120 billion total parameters and 12 billion active per token. Its hybrid Mamba-2/Transformer MoE architecture integrates a C-RADIO vision encoder, supporting text alongside images, document pages, charts, GUI screenshots, and video frames. NVIDIA describes a context capacity of up to one million tokens for supported deployments and pitches it for document intelligence, research, code validation, and long-running specialized agents.

An important nuance: Bolt itself is also a vision-language model. NVIDIA's model card lists text, image, and video inputs for its 24GB checkpoint, and its technical account says Bolt was compressed from Super VL. My Bolt experiments were text-only. Neither model has yet undergone a dedicated vision benchmark in this review, so readers should regard multimodal capabilities as supported features and promising use cases, not results I've independently validated.

The official Super VL technical blog says the model can achieve up to 5x higher throughput than some open peers under NVIDIA's measured agentic settings; other serving recipes may improve concurrent throughput and latency. Those are NVIDIA's benchmark and deployment claims, not the performance measured in my tests.

My Test Setup: Two Very Different Ways to Run AI

Local setup: NVIDIA Nemotron 3.5 Bolt 74B-A9B, IQ2_XXS GGUF, running through Unsloth Studio on Microsoft's Surface Laptop Ultra equipped with NVIDIA RTX Spark and 128GB unified memory. This is an aggressively compressed local configuration. Its behavior should not be assumed to represent every precision, checkpoint, inference engine, or decoding configuration.

Hosted setup: Nemotron 3.5 Super VL in OpenRouter Chat. In this case inference occurred on a remote provider's infrastructure. I did not select or verify the underlying GPU, exact provider route, or served weight precision. OpenRouter reported usage and per-request charges, but not comparable laptop-side throughput data.

The same core prompts covered logic, creative writing, everyday arithmetic, historical hallucination detection, coding, and explanations written for different audiences. Each is a small editorial test, usually a single run, rather than a statistically significant model benchmark. Some tasks involved web search. Their results are therefore useful observations about complete workflows, not clean comparisons of unaided model knowledge.

What Bolt Was Like to Use Locally

The local speed was immediately satisfying. On the straightforward three-box logic puzzle, Bolt decoded at 65.5 tokens per second and answered correctly within the requested 120 words. Across other runs it generally produced around 40 to 65 tokens per second. That makes it feel less like waiting for a large model to wake up and more like using an interactive tool.

It also handled practical business math correctly. Given sales volumes, ingredient costs, and a supplier membership fee for an imaginary coffee shop, it calculated $900 in daily gross profit, $756 in monthly ingredient savings, and a $576 net monthly benefit after the fee. More importantly, it flagged the assumptions that matter in real life: changes in volume, which costs the discount actually covers, and the difference between gross profit and what the business keeps.

That's where I see immediate local value. A private research assistant, a helper for drafting and explaining technical ideas, and a model that can reason through ordinary operational questions without a cloud round trip are all attractive propositions.

Bolt was also able to obey exact word-count constraints. In a three-audience explanation exercise, its 50-word and 150-word versions met their targets. The trade-off was the amount of work it did to get there.

The Surprising Cost of Precise Instructions

One of the clearest findings had little to do with raw intelligence. I asked Bolt to explain AI reasoning to three audiences. With flexible lengths, it generated 2,029 tokens and completed in about 47 seconds. With exact word counts, it generated 6,797 tokens and took about 137 seconds.

That is 3.35 times as many generated tokens and roughly 2.9 times the elapsed time for closely related assignments. The stricter version did obey the counts, so its extra effort bought something real. But its visible reasoning devoted substantial attention to drafting, manual counting, and revising.

Super VL showed a similar pattern on OpenRouter: the relaxed variant used 2,838 reported tokens, while the exact-count version used 6,210, a 2.19x increase. Unlike Bolt's counts, the OpenRouter figures are reported usage totals and should not be compared directly with local generated-token numbers.

There was another wrinkle. Super VL's relaxed-length response omitted the requested software-engineer explanation. Its stricter answer included all three versions and hit the exact 50- and 150-word limits. The increase in tokens therefore partly reflected completing more of the assignment, rather than counting alone.

My takeaway is practical: exact constraints can be worth the additional deliberation when format compliance matters. For casual brainstorming, drafting, or exploratory questions, a little flexibility may make a model more responsive. I would not turn two paired runs into a universal performance law, but the pattern is worth watching.

"Keep it kinda brief" will likely dodge the specificity required by a precise wordcount. Recognizing when you need one of the other will save you time and tokens.

A Fact-Check That Revealed a Real Difference

I supplied both models with a fictional story about a 1987 NASA shuttle mission in which astronaut Daniel Mercer retrieved a Helios-7 probe. No such shuttle mission occurred. NASA flew no shuttle missions in 1987 after the Challenger disaster; STS-26 returned to flight aboard Discovery on September 29, 1988. The Helios program involved Helios 1 and 2, neither a shuttle-recovered Helios-7.

Both models spotted that the premise was false. But Bolt's answer then supplied incorrect historical details about STS-26, including the wrong shuttle and date. Super VL correctly explained why the premise failed and cited NASA-related supporting materials without filling in a fictional recovery.

This was Super VL's clearest win in my small comparison. It was also a tool-assisted task: both transcripts reported web searches, and I can't guarantee they encountered the same results or tool settings. I'd describe it as a better result on this particular research workflow, not proof that one checkpoint is universally more factual.

Coding: Encouraging, With a Big Testing Qualification

I asked both models to create a browser-based, procedurally generated dungeon crawler in a single HTML file. That was an intentionally demanding one-shot assignment, including maps, pathfinding, enemy behavior, combat, and items.

This was absolutely not running debug tests and filling other agentic coding needs, where these models look to be strong. I intentionally opted for a different direction out of curiosity.

Bolt spent about 11 minutes generating roughly 34,916 tokens on the revised challenge. Its program failed during initialization: non-integer room-center coordinates were used as array indices. A second issue in the entity-placement logic could populate most available floor tiles with enemies. Those are genuine defects, but they describe one-shot code generation at this particular quantization and setup. On a single iteration, all was cleaned up and good to go.

Super VL's game started successfully. In a test harness I checked 100 generated dungeons; each had at least five rooms, and the rooms were connected. The initial enemy and item counts were reasonable. I also found reproducible gameplay problems: players could overlap occupied enemy squares, and the ranged enemy's line-of-sight calculation was inconsistent depending on direction. Again, this cleaned up quickly with a single followup prompt, but the first prompt took us much farther.

That is a useful difference in output quality, but it is important to judge the experiment fairly. NVIDIA's stated coding use cases emphasize agentic workflows with tools. A coding agent should inspect files, execute a program, read errors, repair code, run tests, and iterate. Neither of these one-shot runs had that complete edit-run-debug loop.

The next meaningful evaluation is to put both into equivalent coding harnesses and measure verified task completion, tool use, recovery from errors, and time to a tested solution.

Where I'd Reach for Each Model

Bolt is the model I'm most personally excited to keep using right now. For local agents, personal workflows, privacy-sensitive drafts, experimentation with on-device tool use, and situations where keeping inference off the cloud matters, its combination of capability and speed is compelling. It is also an interesting option for builders who want to customize an agent harness and live with a predictable, local compute footprint. Its official 24GB package opens the door to machines with much less memory than my 128GB test laptop, although speed and feature support will depend on the hardware and runtime.

Super VL makes particular sense when agents need to read and reason over what they see: screenshots, charts, financial forms, PDFs, interfaces, image-heavy documents, and video frames. The same model can combine those inputs with text reasoning and tool use. Its hosted availability through OpenRouter and NVIDIA NIM reduces the burden of local deployment, while its open weights also allow organizations with appropriate hardware to self-host and customize it. My text-only tests were positive; the next thing I want to explore is whether its vision abilities deliver on the promise in practical work.

There is no reason to treat the choice as permanent. For some projects, Bolt might be the always-on local worker and Super VL the specialist brought in for heavy document and visual tasks. The economics, data restrictions, latency requirements, and agent framework may decide more than any single benchmark score.

What I Would Watch Next

First: verified agentic coding, ideally using the same broken-code fixture and the same execution tools for both models. Second: local multimodal evaluation, including screenshots and charts, especially on Bolt's 24GB package. Third: lighter 2-, or even 1-bit, Super VL derivatives or quantized variants practical on smaller machines. I am especially eager to see what vision-language capability I can keep entirely local without needing high-end server infrastructure.

I would also watch the effect of reasoning budgets, sampling settings, cache behavior, and quantization. A model that works efficiently inside an agent loop may tell a different story from one answering an exact-word-count writing prompt in chat.

Verdict

After this first round, Nemotron 3.5 looks like a family built around practical deployment choices rather than a single benchmark trophy. Super VL was particularly encouraging in factual verification and generated a more functional first draft of our game. Bolt gave me something I value just as much: useful, interactive reasoning from a large open model on my own laptop.

The most exciting result is the one I keep returning to: 65.5 tokens per second from Bolt locally, on a machine I can pick up and carry. There's a lot more to test, especially around agentic tools and vision, but that's already enough to make me want to keep experimenting.

In 2026, we've watched local open-weight AI go from feeling like a bolted-on novelty to a more serious way to guard your privacy, save a lot of money, and mold models to fit your needs. Smaller models continue to improve and run on lighter and lighter machines, so if you can't work with these yet, be patient. Your time is coming.