TL;DR – Quick Summary
- Nemotron 3.5 Super VL is NVIDIA’s 2026 multimodal agent model combining vision, reasoning, coding, and native tool use in one deployable checkpoint.
- A mixture-of-experts design activates only 12 billion parameters per token despite a 120 billion total parameter count, keeping per-token inference cost competitive with much smaller dense models.
- A 128K token context window supports long documents, multi-frame video, and extended multi-turn agentic task traces that shorter-context models cannot handle reliably.
- Checkpoints are available on Hugging Face under an open commercial license, with deployment paths through Transformers, vLLM, and SGLang.
- Native tool-calling removes the need for a separate function-dispatch layer in most agentic pipeline designs.
According to NVIDIA, Nemotron 3.5 Super VL is the most capable multimodal release in their open model series to date, and the practical implications for teams building specialized AI agents are significant. Released by NVIDIA in 2026, the model brings vision understanding, long-context text reasoning, structured code generation, and tool use together under one architecture that developers can download, run, and fine-tune without a proprietary API dependency. According to NVIDIA, the model totals 120 billion parameters but activates only 12 billion parameters per token thanks to a mixture-of-experts routing mechanism, which means the per-call compute cost is substantially lower than the headline parameter count suggests. For practitioners who have been waiting for a genuinely multimodal open model with agentic depth, this release deserves a direct look.
What distinguishes this release from previous multimodal open models is how deliberately NVIDIA has oriented it toward production agentic workflows. Vision grounding, reasoning modes, code generation, and function calling are treated as core features rather than optional add-ons. The model ships with a detailed model card, clear licensing terms, and framework-specific deployment guidance, which cuts through a lot of the integration guesswork that typically slows adoption of large open models.
Quick Takeaways
- Review the model card and license on Hugging Face before building any commercial pipeline; the permissive terms do cover fine-tuning and production deployment.
- Use vLLM or SGLang for production inference; plain Transformers is fine for local prototyping but will not scale to real throughput requirements.
- Set the context window to your actual workload length rather than defaulting to the 128K maximum; shorter prompts meaningfully reduce memory pressure.
- Tool-calling is natively supported, so for many agent designs you can skip a separate orchestration layer entirely.
The Purpose Behind Nemotron 3.5 Super VL
Nemotron 3.5 Super VL is a multimodal large language model built specifically for agentic AI workflows that require combining vision, reasoning, and tool use in a single call chain. NVIDIA designed it to close the practical gap between frontier research models and systems that enterprise teams can actually deploy for specialized tasks.
The clearest target use cases are AI agents that need to interpret images or video alongside text, reason through multi-step problems, invoke external tools, and return structured outputs. Concrete examples include document-processing agents that extract data from scanned forms, coding assistants that can reference architecture diagrams, and video analysis pipelines that summarize temporal events across long clips. The model is explicitly positioned as a fine-tuning foundation for narrow-domain agents rather than a general-purpose chat assistant, which shapes several of its design decisions.
The 128K token context window directly supports the long multi-turn task traces that agent loops generate. The tool-calling interface is built into the base model weights rather than added through a post-training wrapper, which tends to produce more reliable function-call formatting. The permissive open license covers commercial use and fine-tuning, removing a common barrier for enterprise adoption. The Nemotron project README covers the release scope, checkpoint structure, and intended use in detail.
For organizations already running NVIDIA infrastructure, the model integrates with the NeMo framework and supporting toolchain. For teams on other stacks, the Hugging Face checkpoint and Transformers compatibility mean adoption does not require committing to a fully NVIDIA-specific serving setup from day one.
Multimodal Architecture: Vision, Reasoning, and Long Context
The architecture of this model rests on three interlocking design decisions: a mixture-of-experts backbone, a vision encoder that feeds directly into the language model, and a context window tuned for practical agentic workloads.
The mixture-of-experts backbone is central to the efficiency story. According to NVIDIA (2026), the model has 120 billion total parameters but activates only 12 billion parameters per token during inference. Token routing through specialized expert subnetworks means that different input types can engage different parameter subsets, allowing the full parameter space to contribute to overall capability without requiring every parameter to fire on every token. The practical result is that per-forward-pass compute stays closer to what a 12B dense model requires, not what a 120B dense model would demand.
The vision component handles both images and video frames as input alongside text. A dedicated vision encoder converts visual content into token representations that the language model processes natively, eliminating the need for a separate image preprocessing model in the pipeline. Multi-frame video inputs work within the same context window, enabling temporal reasoning across frame sequences.
The 128K token context window covers workloads that shorter-context models cannot reliably support: long legal or technical documents, multi-turn agentic task histories, and extended coding sessions with full codebase context. Running at the full context length imposes significant memory requirements on the inference side and should be configured deliberately rather than used as a default.
The Nemotron 3 architecture paper on arXiv covers the efficiency design principles and model family structure that carry forward into this generation.
Key Capabilities of Nemotron 3.5 Super VL
Nemotron 3.5 Super VL covers five capability areas that NVIDIA treats as primary design targets, each relevant to a distinct layer of agentic pipeline design.
Vision understanding: The model interprets images and multi-frame video alongside text. It can answer questions about visual content, describe scenes, extract structured data from documents with complex layout, and reason over diagrams, charts, and screenshots within a unified prompt.
Reasoning modes: Both standard and extended reasoning modes are available. Extended reasoning allows the model to produce longer chains of thought before producing a final answer, improving accuracy on mathematical, logical, and multi-step planning problems. Developers can select the mode based on latency tolerance and task complexity.
Code generation and understanding: Strong coding support covers a range of languages and task types, from generating complete functions from natural language specifications to debugging by reasoning over error traces alongside source code.
Tool use: Native tool-calling allows the model to generate correctly formatted function calls to external APIs and consume the returned results within the same conversation turn. This is a foundational requirement for agents that need to retrieve live data, trigger actions in external systems, or verify information before responding.
Long-context synthesis: With 128K tokens of context, the model can synthesize across entire codebases, multi-document research packs, or long task histories, making it practical for retrieval-augmented generation pipelines where large amounts of retrieved content must be integrated before a response is produced.
The Megatron Bridge README covers the distributed serving infrastructure that supports models at this parameter scale within NVIDIA’s ecosystem.
Building Agentic Workflows With This Model
Agentic systems built on this model can handle multi-step tasks that would previously require chaining several specialized models. Because vision, reasoning, and tool use are integrated, a single model call can interpret a screenshot, decide on an action, generate a correctly formatted API function call, and incorporate the returned data into the next reasoning step.
For document-processing agents, a pipeline can ingest a scanned form, extract structured fields, validate the data against a schema, and route the result to the appropriate downstream system within a single model-driven loop. For coding agents, the model can review a code diff, reason about potential bugs introduced by the change, suggest a fix with explanation, and propose a test case, all in one context window.
Tool-calling follows a standard function-calling interface, making it compatible with common orchestration patterns. Developers using frameworks like LangChain or LlamaIndex can register approved tools through the standard interface without significant adapter work. The Automodel repository provides tooling for automated model selection and configuration within NVIDIA’s NeMo ecosystem.
For multi-agent system designs, plan for a dedicated inference endpoint per model instance. The 120B total parameter footprint requires distributed GPU memory; trying to time-share the model across many concurrent high-concurrency workloads on a single node will degrade throughput. Proper batching at the inference layer, which vLLM handles through continuous batching and paged attention, recovers much of the efficiency that parameter count would otherwise cost.
Hardware Requirements and Production Deployment
Running the model at full precision requires multi-GPU infrastructure. The MoE design activates only 12 billion parameters per token, per NVIDIA (2026), but all 120 billion parameters must reside in GPU memory during inference, which demands significant VRAM distributed across multiple devices.
A practical starting point for full-precision serving is four to eight high-memory GPUs, such as H100 80GB cards, depending on batch size and context length targets. Quantization can reduce memory requirements, though teams should benchmark accuracy on their specific task type before committing to a lower-precision serving setup for reasoning-heavy workloads. PyTorch’s distributed inference documentation provides a useful foundation for setting up multi-GPU serving when building outside of NVIDIA’s native toolchain.
| Inference Framework | Best Fit | Context Length Support | Key Advantage |
|---|---|---|---|
| Transformers (HF) | Local prototyping, small batches | Full 128K, memory-limited | Easiest setup, no extra dependencies |
| vLLM | Production multi-user serving | Full 128K with paged attention | Continuous batching, high tokens/sec |
| SGLang | Structured output, tool-call reliability | Full 128K | Constrained decoding for JSON responses |
Source: NVIDIA developer blog deployment guidance, 2026. Current exact configurations should be verified at each framework’s documentation.
For teams without on-premises GPU clusters, cloud-based NVIDIA inference APIs and NGC catalog options offer a lower-barrier path to testing the model at scale. This is worth exploring before committing to a full hardware procurement cycle, particularly for teams still defining their agent workload profile.
Practical Application
Beginner: Start by reading the model card on Hugging Face to confirm the license terms cover your use case, then use the Nemotron README to identify the correct checkpoint variant and download both the language model weights and the required vision encoder components. Load via Transformers with a reduced context length, for example 8K tokens, to confirm your environment runs the model before scaling up.
Intermediate: Switch to vLLM as your inference backend and configure the context window explicitly in the server launch parameters to match your workload length rather than defaulting to the 128K maximum. Prepare image inputs in the format specified in the model card and run multi-modal prompts against test cases before enabling tool calling. Profile memory usage at your target batch size before moving to production traffic.
Advanced: Enable the native tool-calling interface by registering your approved tools through the standard function-calling schema, then use SGLang’s constrained decoding to guarantee JSON-formatted tool responses for downstream parsing reliability. Integrate model selection automation through the Automodel tooling, monitor MoE expert routing distributions with profiling to verify the model is engaging domain-relevant experts for your workload, and configure multi-agent orchestration with an explicit maximum tool-call depth before any production rollout.
Nemotron 3.5 Super VL fills a meaningful gap in the open model ecosystem: a large multimodal AI system with genuine agentic depth that practitioners can deploy, fine-tune, and integrate without a proprietary API dependency. The MoE efficiency makes the 120B parameter count more approachable than it appears on paper, and the combination of vision, long-context reasoning, and native tool use removes several integration layers that developers currently build by hand. For teams with the infrastructure to support it, a serious evaluation is warranted now rather than after the ecosystem matures further around it.
| feature | detail |
|---|---|
| Total parameters | 120 billion |
| Active parameters per token | 12 billion |
| Context window | 128K tokens |
| Architecture | Mixture-of-Experts |
| Tool calling | Native, no extra layer |
| License | Open commercial |
Frequently Asked Questions
Q: What is NVIDIA Nemotron 3.5 Super VL designed for?
It is designed for agentic AI workflows that combine vision understanding, multi-step reasoning, code generation, and tool use in a single system. NVIDIA targets it at specialized enterprise agents rather than general-purpose chat, meaning teams are expected to fine-tune or adapt it for specific task domains rather than using the base model directly.
Q: What modalities does Nemotron 3.5 Super VL support?
The model processes text, images, and video frames as input. A dedicated vision encoder converts visual inputs into tokens that the language model handles natively, allowing text and image content to be combined in a single prompt without a separate preprocessing pipeline or a second model call.
Q: What is the context window of Nemotron 3.5 Super VL?
The model supports a 128K token context window, making it practical for long-document analysis, extended multi-turn agent traces, and multi-frame video reasoning. Running at the full 128K length requires careful memory planning on the inference side; most production deployments configure a shorter effective window matched to actual workload requirements.
Q: Can developers fine-tune Nemotron 3.5 Super VL?
Yes. The model ships under a permissive open license that covers fine-tuning and commercial use. NVIDIA provides checkpoints on Hugging Face and documentation through the NeMo framework. Teams building domain-specific agents are explicitly encouraged to fine-tune for their target task rather than rely on the base model with prompting alone.
Q: What hardware is needed to run Nemotron 3.5 Super VL?
According to NVIDIA (2026), the model has 120 billion total parameters, requiring multi-GPU infrastructure with substantial combined VRAM. A practical starting configuration is four to eight H100 80GB GPUs for full-precision inference. Quantization can lower hardware requirements, though accuracy should be validated for demanding reasoning tasks before deploying at lower precision.
