Nemotron 3.5 Super VL: NVIDIA's open vision model for agents, explained

Why I care about a vision model

I build eesel's integrations, the code that pulls tickets, attachments and help-center articles out of tools like Zendesk and Freshdesk. Most of what flows through that plumbing is text, but not all of it. One request kept coming up in eesel's sales calls this year: technical-product support teams wanted the AI to read the diagrams inside their PDFs and the photos customers attach to tickets. A public-sector IT firm handling about 3,000 complex tickets a month told us its technical documentation was mostly images.

So when NVIDIA shipped an open model whose whole pitch is "one model that reads charts, tables, page layouts and video, then calls tools," I read the model card line by line. Here's what's actually in it, where the launch claims hold up, and where they need a footnote.

What is Nemotron 3.5 Super VL?

Nemotron 3.5 Super VL is the vision-language member of NVIDIA's Nemotron 3.5 family. The BF16 model card describes it as a model for "reasoning, coding, tool use, document understanding, and video understanding," and the key word is one. Instead of chaining a text model to a separate vision model and passing context between them, the same weights handle both.

It launched alongside two smaller siblings. Per NVIDIA's announcement, Bolt 74B-A9B uses native 2-bit quantization to fit in 24GB for local agents, and Bolt E4B (4GB) arrives on 23 October for voice and embedded use.

Here are the specs that matter:

The model card says it is "ready for commercial or non-commercial use," and NVIDIA is releasing the training data and recipes too. That last part matters if you plan to fine-tune. You can see what went in, which you can't with most open-weights models, including Kimi K3 and Mistral Large 4.

How does it work under the hood?

The short version: it's a medium-sized model built to do a lot of work per GPU. A few design choices explain why it's fast.

• Hybrid layers. The network interleaves Mamba-2 layers (a state-space design that handles long sequences cheaply) with mixture-of-experts blocks and a smaller number of attention layers. That keeps memory for long context low, which is how one box can hold a 1M-token window.
• Distilled from a bigger model. NVIDIA says the backbone started from Nemotron 3 Super Base, then took 1T tokens of distillation from Nemotron 3 Ultra Base. That's how a 120B model ends up beating its 550B teacher on some agent benchmarks.
• Built-in drafting. A multi-token prediction head proposes several tokens at once for the main model to check, so it needs fewer expensive passes. On DGX Spark, NVIDIA's separate LiLiCorr drafter adds "up to 2.3x faster token generation."
• 4-bit without much loss. The NVFP4 checkpoint was trained to match the full-precision model. Artificial Analysis found it scores within 0.1 points of BF16 on its index.

The training pipeline also explains the agent focus: 67B tokens of software-engineering mid-training at 256K context, then supervised fine-tuning on packed sequences of up to 524,288 tokens, then reinforcement learning and multi-teacher distillation. If you've been following how AI agents are built, this is the recipe you'd expect for a model meant to run long, tool-heavy jobs.

Where it fits in NVIDIA's model lineup

NVIDIA is clear that Super VL isn't meant to do everything. In its developer post, it describes a "system of models": Nemotron 3.5 Lightning handles high-volume text tasks, Nemotron 3 Ultra handles planning and orchestration, and Super VL sits in the middle doing the specialized, multistep work that needs vision and tools.

That framing is useful because it tells you how NVIDIA expects you to use it. Super VL is the worker you hand a 40-page PDF and a spreadsheet to, not the cheapest model for classifying a million short messages. For that kind of ticket classification job, Lightning or a small closed model like Claude Haiku 5.5 is the better fit on cost.

How good is it, really?

This is where you need to read two scoreboards side by side.

On Artificial Analysis, the independent benchmarking site, Nemotron 3.5 Super VL scores 26.5 on the Intelligence Index, #1 of 67 open-weights models in the 40B to 150B size class. That's double its predecessor Nemotron 3 Super (13), ahead of Nemotron 3 Ultra (22.9) and just ahead of Thinking Machines' Inkling Small (25.7). It also ran at 409 output tokens per second, the fastest in its class.

But widen the lens and the picture changes. Larger open models that cost about the same per token score much higher:

GLM-5.3-Flash (320B total) scores 41.8 and Qwen3.8-Flash-Next (180B total) scores 39.8. NVIDIA's own model card table includes both, and they beat Super VL on most rows, including SWE-bench Verified (78.7 and 79.10 against 71.10) and Terminal-Bench 2.1 (85.80 and 82.70 against 60.67). Artificial Analysis itself notes the US still trails China's MiMo-V2.6-Pro (46) on open-weights intelligence.

So what does Super VL win on? Speed, and the "most attractive quadrant" of NVIDIA's chart, where accuracy meets throughput:

On agent harnesses specifically, NVIDIA reports it beats Ultra on Hermes Bench (63.44% against 56.33%) and on LangChain's behavioral evals (87.05% against 84.3%). And it's strong on documents: 80.8% on the CharXiv chart-reasoning benchmark (84% with Python code interpretation) and 68.12 on OCRBench v2 English.

My read: Super VL isn't the smartest open model, it's the fastest good one that can see. If your agent mostly writes code, the bigger flash models are worth the extra memory. If it reads documents all day and you care about throughput per GPU, Super VL is the one to test first.

The post-training story NVIDIA leads with

NVIDIA's headline claim, picked up by most launch coverage, is that post-trained Super VL beats Claude Opus 5, GPT-6.1 Sol and other frontier models on specialized tasks. The chart is real. Look at it closely, though:

In all five tasks, the light green base model starts below the frontier model. On security attack resilience it starts around 35% against GPT-6.1 Sol's 66%, and only passes it after a +41% post-training gain from AI21 and Alice. The win comes from training on your own data, which is exactly what an open model with open recipes lets you do.

The partner numbers are concrete. Scale AI post-trained it for vendor credit processing at Skydance and expects inference cost to drop 40x and latency 5x. Ramp is turning receipt images into structured JSON and expects up to 50% higher throughput and 10x lower latency.

The lesson for buyers: if you'll pick a model off the shelf and prompt it, compare base scores. If you have a team and labeled data to post-train with NVIDIA NeMo, Super VL's open recipe is the real product.

What does Nemotron 3.5 Super VL cost?

The weights are free. Hosted, it's one of the cheapest capable models on the market:

The OpenRouter rows come from OpenRouter's model page as of 18 October. One warning on the free endpoint: OpenRouter's notice says your use "is logged for security purposes and to improve NVIDIA products," and asks you not to upload confidential or personal data. That rules it out for real customer tickets.

Sticker price isn't the whole bill, because reasoning models burn output tokens. Artificial Analysis measured $0.19 per Intelligence Index task, cheaper than GLM-5.3-Flash ($0.28) and Qwen3.8-Flash-Next ($0.37) despite similar list prices, because Super VL used about 46,000 output tokens per task. That's roughly 60% fewer than Nemotron 3 Super.

To see what that means for a support workload, plug in your own numbers:

At the defaults, 10,000 tickets cost about $13 a month in tokens on DeepInfra. That's the point I'd want a support lead to take away: the model bill is the small number. The expensive parts are everything around it, like retrieval, escalation rules, testing and keeping answers current, which is the same conclusion my support model guide reaches for closed models.

Can you run it yourself?

Yes, and this is where Super VL stands out. NVIDIA built the NVFP4 checkpoint to fit on a single DGX Spark, and the hosted list on launch day was long: Hugging Face, ModelScope, NIM, plus LM Studio, Ollama, vLLM, SGLang and Unsloth for local runs.

The numbers come from the NVFP4 model card and Unsloth's guide, which lists GGUF builds from 46.1GB (1-bit) to 132GB (8-bit). Quality holds up well in 4-bit. NVIDIA's side-by-side table shows NVFP4 within a point of BF16 on most benchmarks, though WebVoyager drops from 77.72 to 66.31, so test browsing agents on the quantized build before you trust it.

For production, NVIDIA packages it as a NIM microservice and says its Dynamo serving recipe, on 16 B200 GPUs, "serves up to 8x as many users while reducing first-token latency by 85%." If you self-host for data-residency reasons, pair it with a sandbox like NVIDIA's Open Agent Safety Platform or the NemoClaw runtime rather than giving it raw tool access.

The license is the cleanest part of the story. OpenMDW-1.1 grants rights "without restriction," asks only that you keep the license and notices when you redistribute, and says it imposes no restrictions on outputs. There's no revenue threshold and no "Built with" label requirement, unlike Muse Spark Open.

What are early testers saying?

The first wave of reaction splits cleanly: impressed by the speed and the US ranking, more cautious once people run it against Qwen.

Artificial Analysis framed the launch around its national ranking:

"Nvidia's Nemotron 3.5 Super VL is now the leading US open weight model, scoring 26 on the Artificial Analysis Intelligence Index"

Artificial Analysis, X

Harrison Kinsley, who runs the Sentdex channel, was testing it for local coding:

"This one may very well be a solid choice for a speedy local coding agent model"

Harrison Kinsley (Sentdex), X

The most useful test I found came from Peter Dedene, who ran Super VL and Qwen3.8-Flash-Next through his own agent benchmark with thinking turned off. Tool calling and instruction following came out close. Prompt injection did not: on AgentDojo, where a malicious instruction hides inside a tool's output, Qwen followed it in 2 of 200 runs and Nemotron in 37.

"For an agent that touches untrusted input, I'd still pick Qwen. For long documents, Nemotron."

Peter Dedene, X

He's careful to note Nemotron is built to reason and he tested it with reasoning off, so it isn't the model's best case, and he plans a second run. On Hacker News, the reaction was shorter:

"this 3.5 Super is still below Qwen 3.8 next as they state themsleves"

scirob, Hacker News

That matches NVIDIA's own table, so it's fair. NVIDIA never claimed to beat Qwen on raw scores. It claims speed, openness and post-training headroom.

Is it a good fit for customer support?

This is the question I care about most, and the answer is "it depends on what you mean by fit."

The vision is a real fit. Customers send screenshots of error messages, photos of damaged products and PDFs of invoices. A text-only model sees "see attached" and nothing else. Super VL reads the attachment in the same pass as the ticket, which is the exact gap those technical support teams kept raising on eesel's calls. If you're building your own pipeline with something like LangChain, that removes a whole hop from your support RAG pipeline.

The support benchmarks are middling. NVIDIA's model card reports tau2-bench, the simulated customer-service benchmark where an agent has to follow a company policy while talking to a simulated customer:

Super VL trails all three peers on every row except banking, where it edges Ultra. Its hallucination rate on AA-Omniscience (30.0% on NVIDIA's run) is better than most models in the table, which counts for something in support, where a confident wrong answer is the worst outcome.

Prompt injection is the real risk. Every customer message is untrusted input. Dedene's 37-in-200 result is one test with reasoning off, but it lines up with a lesson eesel learned the hard way: you can't trust any model to police itself on a live queue. That's why we simulate every rollout against historical tickets before an AI answers a real customer, and why actions like refunds sit behind approval rules. Our guide to AI hallucinations in support goes deeper on the guardrails.

So my verdict for support teams: Super VL is an interesting model to build on if you have engineers, NVIDIA hardware and a reason to keep data in-house. It's not something you point at your Zendesk AI agent queue on Monday. If you're comparing ready-made options instead, my roundup of AI helpdesk software is the better starting point.

Who should use Nemotron 3.5 Super VL?

Here's how I'd decide:

• You run document-heavy agents. Invoices, contracts, receipts, charts in reports. This is what it was trained for, and Ramp and Scale AI are already doing it.
• You need open weights on your own hardware. Regulated data, a DGX Spark under the desk, or a contract that bans outside AI processors. The license and the single-box NVFP4 build make this the easiest big open model to justify.
• You plan to post-train. Open data, open recipes and NeMo support on day one. NVIDIA's best numbers all come after fine-tuning.
• You want the smartest open model. Look at GLM-5.3-Flash or Qwen3.8-Flash-Next first, or step up to closed models like GPT-6 Luna and Gemini 3.8 Flash.
• Your agent reads untrusted input with tools attached. Wait for more injection testing with reasoning on, and sandbox it either way.

For comparison shoppers, DeepSeek V4 Flash is the cheapest text-first alternative, and its vision experiment is the closest open rival on images.

Try eesel

Nemotron 3.5 Super VL is infrastructure: weights, a license and a GPU bill. You'd still have to build the retrieval, the escalation rules, the testing and the audit trail yourself. eesel is the employee. Our AI helpdesk teammate plugs into Zendesk, Freshdesk, Gorgias and the rest, learns from your past tickets and help center, and you can run it against hundreds of your historical tickets before it answers a single customer. That replay is where you catch the prompt-injected reply or the over-confident answer before a customer does, whichever model sits underneath.

If you'd rather drive it from a terminal, the way you'd drive a self-hosted model, the eesel CLI covers it. eesel instructions reads and edits the teammate's standing rules, eesel approvals lists actions waiting on a human, and eesel activity shows each run and why it did what it did. Every command prints JSON and writes accept --dry-run, so a coding agent like Claude Code can manage your support teammate the same way it manages your repo. If you write content rather than answer tickets, the same roster has an AI blog writer.

It's free to start with 100 credits and no card. Try eesel on last month's tickets and see what it would have said, before you price out a single DGX Spark. Plans are on the pricing page.