NVIDIA-Nemotron-3.5-Super-VL-120B-A12B-NVFP4 API & Inference Endpoint

Description

NVIDIA-Nemotron-3.5-Super-VL-120B-A12B-NVFP4 is the quantized release of NVIDIA Nemotron 3.5 Super VL, a vision-language model for reasoning, coding, tool use, document understanding, and video understanding. It uses NVFP4 quantization to reduce memory requirements, with quantization-aware distillation from the BF16 model.

The model combines interleaved Mamba-2, Mixture-of-Experts (MoE), and attention layers with a C-RADIO vision encoder and a vision-language connector. It has 120B total parameters and 12B active parameters and supports context lengths up to 1M tokens. Multi-Token Prediction (MTP) enables native speculative decoding.

This model is ready for commercial or non-commercial use.

Model Summary

Table

Total Parameters	120B (12B active)
Architecture	Mamba-2–Transformer hybrid Mixture of Experts with a C-RADIO vision encoder
Precision	NVFP4 (mixed-precision quantized weights)
Context Length	Up to 1M tokens; deployment settings are listed below
Inputs / Outputs	Text, images, and video / text
Deployment	1× DGX Spark, 1× H200, 2× H100, or 1× GB200
Speculative Decoding	Native Multi-Token Prediction (MTP)
Reasoning Mode	Configurable through the chat template (`enable_thinking=True/False`)
Recommended Sampling	Text: temperature 1.0, top_p 0.95; vision: temperature 0.6, top_p 0.95
Best For	Efficient deployment of text and vision-language agents
License	OpenMDW-1.1

Model Overview

Model Developer: NVIDIA Corporation

What is Nemotron?

NVIDIA Nemotron™ is a family of open models with open weights, training data, and recipes, delivering leading efficiency and accuracy for building specialized AI agents.

Quick Start

This vLLM configuration is intended for DGX Spark (GB10) only. It serves the model with one concurrent sequence and seven speculative tokens per draft using LiLiCorr.

Nemotron 3.5 Super VL has configurable reasoning levels: off, on (medium), and on. Selecting on (medium) will reduce the number of tokens generated compared to on, but may impact accuracy. You can learn about the reasoning budget here!

Use Docker with NVIDIA GPU support and the vllm/vllm-openai:nightly-3f1bcfd82bb2e93fcd364fc7a5491718453a77e2 or (vllm/vllm-openai:v0.32.0) image. If the model requires authentication, set HF_TOKEN in your shell before launching the container.

bash

export MODEL=nvidia/NVIDIA-Nemotron-3.5-Super-VL-120B-A12B-NVFP4export DRAFT_MODEL=nvidia/NVIDIA-Nemotron-3.5-Super-VL-120B-A12B-NVFP4-LiLiCorr

bash

vllm serve $MODEL \  --served-model-name nemotron-3.5-super-vl \  --max-num-seqs 1 \  --trust-remote-code \  --gpu-memory-utilization 0.75 \  --max-num-batched-tokens 8192 \  --speculative_config.model $DRAFT_MODEL\  --speculative_config.num_speculative_tokens 7 \	  --speculative_config.method dflash \  --mamba-backend flashinfer \  --mamba-ssm-cache-dtype float16 \  --enable-mamba-cache-stochastic-rounding \  --mamba-cache-philox-rounds 5 \  --enable-mamba-shared-prefix-checkpoint \  --video-pruning-rate 0.5 \  --media-io-kwargs '{"video": {"fps": 2, "num_frames": 256}}' \  --block-size 64 \  --prefix-match-unit 64 \  --enable-auto-tool-choice \  --tool-call-parser qwen3_coder \  --reasoning-parser nemotron_v3

Wait for the server to finish loading the model and compiling kernels, then check the endpoint:

bash

curl --fail http://localhost:8000/v1/models

All vLLM and SGLang examples use port 8000 and the API model name nemotron-3.5-super-vl. See the API Client for text, image, video, and tool-calling examples.

License/Terms of Use

Governing Download Terms: Use of this model is governed by the OpenMDW License Agreement, version 1.1.

Benchmarks

We evaluated our model on the following benchmarks:

Table with columns: Benchmark, Nemotron 3.5 Super VL BF16, Nemotron 3.5 Super VL NVFP4
Benchmark	Nemotron 3.5 Super VL BF16	Nemotron 3.5 Super VL NVFP4
GPQA-Diamond	89.52	89.90
HLE, text-only	31.79	31.44
MMLU-ProX	76.91	73.76
AA-Omniscience accuracy	26.20	25.86
AA-Omniscience hallucination rate	30.0	27.7
AA-Omniscience index	4.03

The evaluations between the BF16 checkpoint and NVFP4 checkpoint are done with all configs, harnesses, and other non-model parameters held static to ensure fair comparison that isolates the checkpoint impact

We evaluated Nemotron 3.5 Super on a comprehensive suite of benchmarks spanning agentic capabilities, reasoning and knowledge, multimodal, conversational ability and instruction following, long-context understanding, and multilingual performance. All evaluation results for Nemotron 3.5 Super and baselines were collected via NeMo Gym. For reproducibility purposes, more details on the evaluation settings can be found in the NeMo Gym recipes folder and the corresponding reproducibility tutorial. The published recipes specify the benchmark-specific containers, prompts, inference parameters, parser configurations, and scoring settings used to produce the results.

There were a few benchmarks that were not yet onboarded in our open source tools, and for these we used either their official open source implementation or an internal scaffolding that we plan to open source in the future: BabyVision, CharXiv-RQ, MathVision, MMLongBench-Doc, OCR-Reasoning, OCRBench-v2, V*, Video-MME-v2.

Agentic Coding Benchmarks

Additional harness-level coding-agent results for SWE-Bench Pro and Terminal-Bench 2.1 are shown below.

Deployment Geography: Global

Use Case

This model is intended for developers deploying vision-language agents for coding, search, tool-assisted workflows, document question answering, and image and video understanding, on NVIDIA data center and DGX Spark systems.

Release Date

Hugging Face - 10/15/2026 via Hugging Face

Reference(s)

NVIDIA Nemotron 3.5 Super VL and Lightning Technical Report

Model Architecture

Architecture Type: Mamba-2–Transformer hybrid Mixture of Experts (MoE) with Multi-Token Prediction (MTP)
Network Architecture: Nemotron Hybrid MoE with 512 routed experts per MoE layer, a C-RADIO vision encoder, and a vision-language connector
Number of Model Parameters: 120B total / 12B active

Model Design

The model combines sparse expert computation, attention, and Mamba-2 layers to support long-context processing. The vision encoder and connector turn visual inputs into representations processed by the language backbone. A shared MTP head predicts future tokens recursively for speculative decoding.

The model supports up to 1M tokens of context. The prompt, visual inputs, conversation history, tool results, and generated response share this context window. Individual deployment recipes may use a smaller context window to accommodate the available GPU memory and concurrency.

Training Methodology

Stage 1: Foundation and Multi-Token Prediction

The language backbone is initialized from Nemotron 3 Super Base. A shared MTP head is trained for 100B tokens while the backbone remains frozen, followed by 1T tokens of distillation from Nemotron 3 Ultra Base.

Stage 2: Continued Pre-Training and Mid-Training

The model undergoes 100B tokens of Indic continued pre-training, a 35B-token extension to 1M context, 67B tokens of software-engineering mid-training at 256K context, and a final 9B-token long-context recovery stage. Software-engineering data includes repositories, issue–pull-request pairs, commit diffs, build and CI logs, and agent trajectories.

Stage 3: Vision-Language Training

A C-RADIO vision encoder and connector extend the language backbone to visual inputs, including images, document pages, and video frames.

Stage 4: Supervised Fine-Tuning

A two-stage supervised fine-tuning pipeline jointly trains the language and vision components on vision, reasoning, code, tools, chat, safety, and long-context data. Training uses packed sequences of up to 524,288 tokens.

Stage 5: Reinforcement Learning and Distillation

Reinforcement learning with verifiable rewards, reinforcement learning from human feedback, and specialized teacher training improve reasoning, agentic, chat, and vision capabilities. Multi-teacher on-policy distillation consolidates these capabilities into a single model.

Stage 6: MTP Boosting

The MTP head is further trained against the frozen post-trained backbone to improve speculative-decoding acceptance.

Stage 7: Quantization and Quantization-Aware Distillation

The model is quantized with NVIDIA Model Optimizer and refined through quantization-aware distillation using the supervised fine-tuning data blend. The vision encoder, connector, Mamba convolutions, and embeddings remain in BF16, and the MoE router remains in FP32. Inference uses W4A4 on Blackwell and W4A16 on non-Blackwell platforms, according to the serving configuration.

Input

Input Type(s): Text, images, and video
Input Format(s): Text strings, images, and sampled video frames
- Video: mp4, up to 2 minutes.
- Image: Red, Green, Blue (RGB) (jpeg, png)
Input Parameters:
- Video: Three-Dimensional (3D)
- Image: Two-Dimensional (2D)
- Text: One-Dimensional (1D)
Other Properties Related to Input: Maximum context length up to 1M tokens. Documents can be supplied as page images with accompanying text.

Output

Output Type(s): Text
Output Format: String
Output Parameters: One-dimensional sequences
Other Properties Related to Output: Input and output tokens share the configured context window.

Our AI models are designed and optimized to run on NVIDIA GPU-accelerated systems. By leveraging NVIDIA's hardware (e.g. GPU cores) and software frameworks (e.g., CUDA libraries), the model achieves faster training and inference times compared to CPU-only solutions.

Software Integration

Runtime Engine(s): vLLM; SGLang; TensorRT-LLM
Hardware:
- NVIDIA Blackwell
- NVIDIA Hopper
Operating System(s): Linux

The integration of foundation and fine-tuned models into AI systems requires additional testing using use-case-specific data to ensure safe and effective deployment. Following the V-model methodology, iterative testing and validation at both unit and system levels are essential to mitigate risks, meet technical and functional requirements, and ensure compliance with safety and ethical standards before deployment.

Model Version(s)

v1.0 - NVFP4 GA

Quick Start Guide

Choose your deployment

Table with columns: Hardware, Runtime, Configuration
Hardware	Runtime	Configuration
1× DGX Spark	vLLM	Text, image; 1M-token context; MTP with 5 draft tokens
2× H100	vLLM	Text, image, and video; 1M-token context; MTP with 3 draft tokens
1× H200	vLLM	Text, image, and video; 1M-token context; MTP with 3 draft tokens
1× GB200	vLLM	Text, image, and video; 1M-token context; MTP with 5 draft tokens
1× GB200 or 2× H100	SGLang	Text, image; 1M-token context; MTP with 5 draft steps

NIM and Dynamo

For production workloads, leverage our best-in-class deployment solutions:

NVIDIA NIM packages the model with an optimized inference engine, validated configurations, and standard APIs for deployment in cloud and data center environments. Get started with the Nemotron 3.5 Super VL NIM here.

NVIDIA Dynamo is a distributed inference framework. It supports KV-cache-aware routing, KV cache management, and disaggregated serving. Get started with Nemotron 3.5 Super VL Dynamo recipes optimized for 7 HW SKUs across Hopper, Blackwell, and Rubin here.

Running on Local Hardware

For Local inference on DGX Spark, RTX Spark, and RTX Pro 6000 you can find details on running the model through the following libraries:

llama.cpp available here
Unsloth available here

Speculative Decoding

The serving examples enable the model's native MTP head. No separate drafter download is required for these vLLM and SGLang recipes leveraging MTP. In vLLM, num_speculative_tokens controls draft length; in SGLang, the MTP recipe uses EAGLE with speculative-eagle-topk 1.

For DGX Spark, we also provide a LiLiCorr speculative drafter, which accelerates decoding by drafting multiple future tokens in parallel and using a lightweight correlation head to select compatible candidates across adjacent positions. Nemotron Super 3.5 VL verifies the proposed block, allowing generation to advance by multiple accepted tokens per verification step while preserving the target model's output distribution with correct speculative verification. It is recommended to use LiLiCorr for DGX Spark deployments in all scenarios.

Performance depends on hardware, request length, and concurrency. To compare with standard decoding, remove the speculative configuration while keeping the model, workload, sampling parameters, and other server settings the same.

vLLM

Use vllm/vllm-openai:nightly-3f1bcfd82bb2e93fcd364fc7a5491718453a77e2 for these commands (or vllm/vllm-openai:v0.32.0).

2× H100 (up to 1M Context Length)

Use this command if you need to serve the model with up to 1M context length.

bash

vllm serve $MODEL \  --served-model-name nemotron-3.5-super-vl \  --tensor-parallel-size 2 \  --max-num-seqs 128 \  --trust-remote-code \  --gpu-memory-utilization 0.89 \  --max-num-batched-tokens 16384 \  --block-size 64 \  --prefix-match-unit 64 \  --compilation_config.max_cudagraph_capture_size 256 \  --mamba-backend flashinfer \  --mamba-ssm-cache-dtype float16 \  --enable-mamba-cache-stochastic-rounding \  --mamba-cache-philox-rounds 5 \  --enable-mamba-shared-prefix-checkpoint \  --mamba-cache-mode align \  --speculative-config.method mtp \  --speculative-config.num_speculative_tokens 3 \  --video-pruning-rate 0.5 \  --media-io-kwargs '{"video": {"fps": 2, "num_frames": 256}}' \  --enable-auto-tool-choice \  --tool-call-parser qwen3_coder \  --reasoning-parser nemotron_v3

For one H200, use the same command with --tensor-parallel-size 1.

1× GB200 (up to 1M Context Length)

Use this command if you need to serve the model with up to 1M context length.

bash

vllm serve $MODEL \  --served-model-name nemotron-3.5-super-vl \  --trust-remote-code \  --max-num-seqs 512 \  --enable-prefix-caching \  --max-num-batched-tokens 32768 \  --prefix-match-unit 16 \  --enable-mamba-shared-prefix-checkpoint \  --async-scheduling \  --kernel-config '{"linear_backend_per_quant":{"fp8_w8a8":"torch"}}' \  --compilation-config '{"pass_config":{"fuse_attn_quant":true},"use_inductor_graph_partition":true,"cudagraph_mode":"FULL_AND_PIECEWISE"}' \  --mamba-backend flashinfer \  --mamba-ssm-cache-dtype float16 \  --enable-mamba-cache-stochastic-rounding \  --mamba-cache-philox-rounds 5 \  --mamba-cache-mode align \  --video-pruning-rate 0.5 \  --media-io-kwargs '{"video": {"fps": 2, "num_frames": 256}}' \  --enable-auto-tool-choice \  --speculative_config.method mtp \  --speculative_config.num_speculative_tokens 5 \  --tool-call-parser qwen3_coder \  --reasoning-parser nemotron_v3

For the multimodal examples, each request can contain one image and one video. The video configuration samples up to 256 frames at 2 FPS with a pruning rate of 0.5. For 1080p videos, use 1 FPS and up to 128 frames; 2 FPS and 256 frames can be used for lower-resolution video such as 720p. Start with short MP4 clips of one to two minutes.

SGLang

Use lmsysorg/sglang:v0.5.20. The example below runs on one GB200 GPU. For two H100 GPUs, add --tp-size 2.

bash

docker run --rm --gpus all --ipc=host \  -p 8000:8000 \  -e HF_TOKEN \  -v "$HOME/.cache/huggingface:/root/.cache/huggingface" \  --entrypoint sglang lmsysorg/sglang:v0.5.20 \      serve --model-path "$MODEL_CKPT" \  --served-model-name nemotron-3.5-super-vl \  --host 0.0.0.0 \  --port 8000 \  --trust-remote-code \  --mamba-backend flashinfer \  --reasoning-parser nemotron_3 \  --tool-call-parser qwen3_coder \  --mamba-ssm-dtype float16 \  --enable-mamba-cache-stochastic-rounding \  --mamba-cache-philox-rounds 5 \  --speculative-algorithm EAGLE \  --speculative-num-steps 5 \  --speculative-eagle-topk 1

TensorRT-LLM

The following configurations use TensorRT-LLM 1.3.0rc28, built from commit 55f7eca861613bd60e1ac34d5916f091cd89d558 with Python 3.12 and the Mamba cache patch.

Download the NVFP4 checkpoint locally:

bash

hf download "$MODEL_CKPT" --local-dir ./models/super-vl-nvfp4

1× GB200

Save the following as super-vl-gb200.yaml:

yaml

tensor_parallel_size: 1moe_expert_parallel_size: 1trust_remote_code: trueenable_chunked_prefill: truedisable_overlap_scheduler: falsemax_batch_size: 16max_num_tokens: 8192max_seq_len: 1048576attn_backend: TRTLLMmoe_config:  backend: TRTLLMkv_cache_config:  dtype: fp8  tokens_per_block: 32  mamba_ssm_cache_dtype: float16  mamba_ssm_stochastic_rounding: false  free_gpu_memory_fraction: 0.85  enable_block_reuse: true  mamba_state_config:    periodic_snapshot_interval: 0    additional_snapshot_offsets_from_start: [50016]    additional_snapshot_offsets_from_end: [0]    enable_branch_snapshot: truecuda_graph_config:  enable_padding: true  batch_sizes: [1, 2, 4, 8, 12, 16]speculative_config:  decoding_type: MTP  max_draft_len: 5guided_decoding_backend: xgrammar

bash

trtllm-serve ./models/super-vl-nvfp4 \  --config super-vl-gb200.yaml \  --served_model_name nemotron-3.5-super-vl \  --host 0.0.0.0 \  --port 8000 \  --tool_parser qwen3_coder \  --reasoning_parser nemotron-v3

max_seq_len sets the context limit; max_num_tokens controls the token batch size. For TensorRT-LLM clients, use the model identifier returned by /v1/models.

1× DGX Spark

Save the following as super-vl-gb200.yaml:

yaml

trust_remote_code: truedtype: bfloat16tensor_parallel_size: 1moe_expert_parallel_size: 1max_batch_size: 2max_num_tokens: 4096max_seq_len: 131072 enable_chunked_prefill: truedisable_overlap_scheduler: falsecuda_graph_config: nullattn_backend: TRTLLM kv_cache_config:  dtype: fp8  free_gpu_memory_fraction: 0.9  max_gpu_total_bytes: 5368709120  host_cache_size: 0  mamba_ssm_cache_dtype: float16  mamba_ssm_stochastic_rounding: false  enable_block_reuse: true  use_kv_cache_manager_v2: true  mamba_state_config:    enable_branch_snapshot: true nvfp4_gemm_config:  allowed_backends: [cutlass, cublaslt, cuda_core] moe_config:  backend: CUTEDSL speculative_config:  decoding_type: DFlash  speculative_model: ./models/super-vl-lilicorr  max_draft_len: 7  attention_backend: TRTLLM  context_recompute_tail: 0 guided_decoding_backend: xgrammar

bash

trtllm-serve ./models/super-vl-nvfp4 \  --config super-vl-spark-lilicorr.yaml \  --served_model_name nemotron-3.5-super-vl \  --host 0.0.0.0 \  --port 8000 \  --reasoning_parser nemotron-v3

API Client

Install the OpenAI-compatible client:

bash

pip install openai

Text and reasoning

python

from openai import OpenAI client = OpenAI(base_url="http://localhost:8000/v1", api_key="EMPTY")model = "nemotron-3.5-super-vl" response = client.chat.completions.create(    model=model,    messages=[{"role": "user", "content": "Explain why binary search takes logarithmic time."}],    temperature=1.0,    top_p=0.95,    max_tokens=16384,    extra_body={"chat_template_kwargs": {"enable_thinking": True}},)choice = response.choices[0]if choice.finish_reason == "length":    raise RuntimeError("The response reached max_tokens; increase the output budget.")print(choice.message.content)

Set enable_thinking to False to disable reasoning. For medium reasoning effort, use {"enable_thinking": True, "medium_effort": True}. Reasoning tokens and the final answer share the max_tokens budget.

Images

Use a multimodal server configuration. The example below sends a local image as a base64 data URL.

python

import base64from pathlib import Pathfrom openai import OpenAI client = OpenAI(base_url="http://localhost:8000/v1", api_key="EMPTY")image_bytes = Path("image.png").read_bytes()image_url = "data:image/png;base64," + base64.b64encode(image_bytes).decode() response = client.chat.completions.create(    model="nemotron-3.5-super-vl",    messages=[{"role": "user", "content": [        {"type": "text", "text": "Describe the image and any visible text."},        {"type": "image_url", "image_url": {"url": image_url}},    ]}],    temperature=1.0,    top_p=0.95,    max_tokens=16384,)if response.choices[0].finish_reason == "length":    raise RuntimeError("The response reached max_tokens; increase the output budget.")print(response.choices[0].message.content)

Video with vLLM

Use a multimodal vLLM configuration with the video sampling settings above.

python

import base64from pathlib import Pathfrom openai import OpenAI client = OpenAI(base_url="http://localhost:8000/v1", api_key="EMPTY")video_bytes = Path("video.mp4").read_bytes()video_url = "data:video/mp4;base64," + base64.b64encode(video_bytes).decode() response = client.chat.completions.create(    model="nemotron-3.5-super-vl",    messages=[{"role": "user", "content": [        {"type": "text", "text": "Summarize the events in this video in order."},        {"type": "video_url", "video_url": {"url": video_url}},    ]}],    temperature=1.0,    top_p=0.95,    max_tokens=16384,)if response.choices[0].finish_reason == "length":    raise RuntimeError("The response reached max_tokens; increase the output budget.")print(response.choices[0].message.content)

Tool calling

The model requests a tool call; the application executes it and returns the result. This complete example uses a local inventory lookup.

python

import jsonfrom openai import OpenAI client = OpenAI(base_url="http://localhost:8000/v1", api_key="EMPTY")model = "nemotron-3.5-super-vl"inventory = {"keyboard": 12, "monitor": 5}tools = [{"type": "function", "function": {    "name": "get_inventory",    "description": "Return the inventory count for a product.",    "parameters": {        "type": "object",        "properties": {"product": {"type": "string", "enum": ["keyboard", "monitor"]}},        "required": ["product"],        "additionalProperties": False,    },}}]messages = [{"role": "user", "content": "How many keyboards are in stock?"}] def complete(history, tool_choice="auto"):    response = client.chat.completions.create(        model=model,        messages=history,        tools=tools,        tool_choice=tool_choice,        temperature=1.0,        top_p=0.95,        max_tokens=16384,        extra_body={"chat_template_kwargs": {"enable_thinking": True}},    )    choice = response.choices[0]    if choice.finish_reason == "length":        raise RuntimeError("The response was truncated; increase max_tokens.")    return choice.message message = complete(messages)messages.append(message.model_dump(exclude_none=True))if not message.tool_calls:    print(message.content)else:    for call in message.tool_calls:        arguments = json.loads(call.function.arguments)        if (call.function.name != "get_inventory"                or not isinstance(arguments, dict)                or set(arguments) != {"product"}                or not isinstance(arguments["product"], str)                or arguments["product"] not in inventory):            raise ValueError("Invalid inventory tool call")        product = arguments["product"]        messages.append({            "role": "tool",            "tool_call_id": call.id,            "content": json.dumps({"product": product, "count": inventory[product]}),        })    print(complete(messages, tool_choice="none").content)

Training, Testing, and Evaluation Datasets

Training

Data Modality: Text, images, and video
Foundation Training Data Size: More than 20 trillion tokens Image Training Data Size: 1 Million to 1 Billion Images Text Training Data Size: More than 10 Trillion Tokens Video Training Data Size: 10,000 to 1 Million Hours Foundation Data Collection Period: 2013 to December 2025
Data Collection Method: Hybrid: automated, manually-collected, and synthetic
Labeling Method: Hybrid: automated, manually-labeled, and synthetic

The foundation corpus contains curated and synthetic text covering English, 19 other spoken languages, and 43 programming languages. Sources include webpages, dialogue, articles, code, and other written materials across math, science, legal, finance, and general knowledge domains.

The post-training corpus includes reasoning, coding, tool use, instruction following, structured outputs, chat, safety, and long-context tasks, together with image and video understanding. Synthetic trajectories are filtered for structural correctness, repetition, and task validity.

For more information about the datasets used to train this model, please see the Public Summary of Training Content

Base Pre-Training Corpus (Nemotron 3 Foundation)

The foundation of the model is trained on the Nemotron 3 corpus, comprising the following datasets from the Nemotron Pretraining Datasets collection:

Table with columns: Dataset Collection, Token Counts, Description
Dataset Collection	Token Counts	Description
Nemotron-CC-v2 & v2.1	9.1T	A massive collection of English web data filtered from Common Crawl, including 2.5T+ tokens of new organic, translated, and synthetically rephrased content.
Nemotron-CC-Code-v1	427.9B	High-quality code tokens extracted from Common Crawl using the Lynx + LLM pipeline to preserve structure and equations.
Nemotron-Pretraining-Code-v1 & v2 & v3	1.7T	Curated GitHub code references with multi-stage filtering, deduplication, and large-scale synthetic code data.
Nemotron-CC-Math-v1	133.3B	High-quality math pre-training dataset preserving LaTeX formatting and mathematical structures.

Public Datasets

Table with columns: Dataset, Collection Period
Dataset	Collection Period
GSM8K	4/23/2025
CC-NEWS	4/23/2025
Common Crawl	4/23/2025
Wikimedia	4/23/2025
Bespoke-Stratos-17k

Crawled and Scraped from Online Sources by NVIDIA

The English Common Crawl data was downloaded from the Common Crawl Foundation (see their FAQ for details on their crawling) and includes the snapshots CC-MAIN-2013-20 through CC-MAIN-2025-13. The data was subsequently deduplicated and filtered in various ways used in the Nemotron-CC data pipeline. Additionally, we extracted data for fifteen languages from the following three Common Crawl snapshots: CC-MAIN-2024-51, CC-MAIN-2025-08, CC-MAIN-2025-18. The fifteen languages included were Arabic, Chinese, Danish, Dutch, French, German, Italian, Japanese, Korean, Polish, Portuguese, Russian, Spanish, Swedish, and Thai. As we did not have reliable multilingual model-based quality classifiers available, we applied just heuristic filtering instead—similar to what we did for lower quality English data in the Nemotron-CC pipeline, but selectively removing some filters for some languages that did not work well. Deduplication was done in the same way as for Nemotron-CC.

The GitHub Crawl was collected using the GitHub REST API and the Amazon S3 API. Each crawl was operated in accordance with the rate limits set by its respective source, either GitHub or S3. We collect raw source code and subsequently remove any having a license which does not exist in our permissive-license set.

Table with columns: Dataset, Modality, Dataset Size, Collection Period, Collecting Organisation
Dataset	Modality	Dataset Size	Collection Period	Collecting Organisation
English Common Crawl	Text	3.36T	4/8/2025	NVIDIA Advanced Deep Learning Research
English Common Crawl 1.1	Text	Not disclosed	10/2/2025	NVIDIA Advanced Deep Learning Research
Multilingual Common Crawl	Text	812.7B	5/1/2025

Private Non-publicly Accessible Datasets of Third Parties

Table with columns: Dataset, Model(s) used
Dataset	Model(s) used
Global Regulation	Unknown
TAUS Translation Memory	Unknown
Scale HLE	Unknown
HackerRank Coding	Unknown
RL data for Search	Gemini 3; GPT-5
Mercor SWE-AgentsV1	Undisclosed
KeenSight Batch 1, Relabeled Subset	Qwen3.5-122B-A10B
KeenSight Batch 1, Remaining Subset	Qwen3.5-122B-A10B
Camio Multilingual OCR and Document Layout

Private Non-publicly Accessible Datasets by NVIDIA

Table with columns: Dataset, Model(s) used
Dataset	Model(s) used
Simple Minesweeper	Undisclosed
Simple Sudoku	Undisclosed
Multitool Typewriter Hard	Undisclosed
Machine Translation of News Commentary and TAUS Translation Memory	Undisclosed
Machine Translation of STEM -	Qwen2.5-14B-Instruct
Competitive Coding RL data from Nemotron Cascade	Undisclosed
Long context RL	Undisclosed
Single-step SWE RL for patch generation

NVIDIA-Sourced Synthetic Datasets (Pre-Training)

Table with columns: Dataset, Modality, Dataset Size, Seed Dataset, Model(s) used for generation
Dataset	Modality	Dataset Size	Seed Dataset	Model(s) used for generation
Nemotron-Pretraining-Fact-Seeking	Text	35.0B	FineWiki	Qwen3-30B-A3B-Instruct-2507
Nemotron-Pretraining-Legal	Text	4.3B	CommonPile (caselaw_access_project_filtered); California Code of Regulations; Judicial Ethics Opinions; GLOBALCIT; ; Nemotron Personas; ; CodeHima/TOS_Dataset; ; CaseHOLD; Code of Federal Regulations; (subsets that allow commercial use)

NVIDIA-Sourced Synthetic Datasets (Post-Training)

Table with columns: Dataset, Modality, Dataset Size, Seed Dataset, Model(s) used for generation
Dataset	Modality	Dataset Size	Seed Dataset	Model(s) used for generation
Synthetic Single-Step Tool Use — RL	Text	Approximately 1,433,203 samples	Handwritten prompts; no external seed data	DeepSeek-V3.2; DeepSeek-R1-0528; Qwen3-235B-A22B-Thinking-2507; Qwen3-32B
Synthetic Sparse Tables with Mixed Prompts	Text and images	100,000 records	Generated in-house; no external seed data	None; generated without an SDG model
Synthetic Single-Step Tool Use — RL	Text	Approximately 1,433,203 samples

Language Distribution in Post-Training

For our post-training recipe, we focused on the following languages in addition to English: French, German, Italian, Japanese, Spanish, and Chinese. Those languages were represented in the form of multilingual reasoning and translation tasks.

Additional Training Data

Table with columns: Data, Composition and Purpose
Data	Composition and Purpose
Indic continued pre-training	100B tokens: 10B selected Indic tokens and 90B tokens from the preceding blend.
Software-engineering mid-training	67B tokens: whole repositories (20%), issue–pull-request pairs (41%), commit diffs (3%), build and CI logs (1%), agent traces (10%), pre-training replay (20%), and long-context data (5%). Sources are decontaminated against SWE-bench and Terminal-Bench repositories.
Long-context pre-training	A 35B-token extension to 1M context, followed by a 9B-token long-context recovery stage.
Vision-language data	Image and video data from the Nemotron 3 Nano Omni training corpus, including visual question answering, charts, tables, OCR, multi-page documents, visual grounding, and video understanding.

Table with columns: Post-Training Data, Composition and Purpose
Post-Training Data	Composition and Purpose
Additional synthetic vision data	Chart understanding, grounded perception, multimodal reasoning, and visual tool-use trajectories, including data generated with Qwen3.5 and Kimi models.
Reasoning trajectories	Mathematics and STEM responses generated with Kimi K3; mathematical proofs generated with DeepSeek V4 Pro; competitive-programming trajectories generated with GLM-5.2.
Chat and safety	Refreshed chat responses from Qwen, Kimi, and Gemma models, with additional safety data.
Long-context supervised data	512K-context data, synthetic graph reasoning and transduction tasks, long-horizon search and coding trajectories, and documents containing up to hundreds of pages.
Long-document translation	Chunked translations of PG19 and FinePDFs-Edu documents generated with DeepSeek V4 Flash.

Testing Datasets

Data Collection Method: Hybrid: automated, manually-collected, and synthetic
Labeling Method: Hybrid: automated, manually-labeled, and synthetic
Properties: Standard benchmarks and task-specific test suites covering reasoning, coding, tool use, instruction following, long context, and visual understanding.

Evaluation Datasets

Inference

Acceleration Engine: PyTorch
Test Hardware:
- NVIDIA Hopper
  - H100
  - H200
- NVIDIA Grace Blackwell
  - GB200
  - GB300
- NVIDIA Blackwell
  - B200
  - B300

The deployment examples above provide configurations for NVIDIA Hopper and Blackwell systems. Choose the precision, context length, and concurrency appropriate for the application and available memory.

Ethical Considerations

NVIDIA believes Trustworthy AI is a shared responsibility and we have established policies and practices to enable development for a wide array of AI applications. When downloaded or used in accordance with our terms of service, developers should work with their internal model team to ensure this model meets requirements for the relevant industry and use case and addresses unforeseen product misuse.

We advise against circumvention of any provided safety guardrails contained in the Model without a substantially similar guardrail appropriate for your use case. For more details: Safety and Explainability subcards. For more detailed information on ethical considerations for this model, please see the Model Card++ Bias, and Privacy subcards.

Please report model quality, risk, security vulnerabilities or NVIDIA AI Concerns here.

Description

This model is ready for commercial or non-commercial use.

Model Summary

Table

Total Parameters	120B (12B active)
Architecture	Mamba-2–Transformer hybrid Mixture of Experts with a C-RADIO vision encoder
Precision	NVFP4 (mixed-precision quantized weights)
Context Length	Up to 1M tokens; deployment settings are listed below
Inputs / Outputs	Text, images, and video / text
Deployment	1× DGX Spark, 1× H200, 2× H100, or 1× GB200
Speculative Decoding	Native Multi-Token Prediction (MTP)
Reasoning Mode	Configurable through the chat template (`enable_thinking=True/False`)
Recommended Sampling	Text: temperature 1.0, top_p 0.95; vision: temperature 0.6, top_p 0.95
Best For	Efficient deployment of text and vision-language agents
License	OpenMDW-1.1

Model Overview

Model Developer: NVIDIA Corporation

What is Nemotron?

NVIDIA Nemotron™ is a family of open models with open weights, training data, and recipes, delivering leading efficiency and accuracy for building specialized AI agents.

Quick Start

This vLLM configuration is intended for DGX Spark (GB10) only. It serves the model with one concurrent sequence and seven speculative tokens per draft using LiLiCorr.

Nemotron 3.5 Super VL has configurable reasoning levels: off, on (medium), and on. Selecting on (medium) will reduce the number of tokens generated compared to on, but may impact accuracy. You can learn about the reasoning budget here!

bash

export MODEL=nvidia/NVIDIA-Nemotron-3.5-Super-VL-120B-A12B-NVFP4export DRAFT_MODEL=nvidia/NVIDIA-Nemotron-3.5-Super-VL-120B-A12B-NVFP4-LiLiCorr

bash

vllm serve $MODEL \  --served-model-name nemotron-3.5-super-vl \  --max-num-seqs 1 \  --trust-remote-code \  --gpu-memory-utilization 0.75 \  --max-num-batched-tokens 8192 \  --speculative_config.model $DRAFT_MODEL\  --speculative_config.num_speculative_tokens 7 \	  --speculative_config.method dflash \  --mamba-backend flashinfer \  --mamba-ssm-cache-dtype float16 \  --enable-mamba-cache-stochastic-rounding \  --mamba-cache-philox-rounds 5 \  --enable-mamba-shared-prefix-checkpoint \  --video-pruning-rate 0.5 \  --media-io-kwargs '{"video": {"fps": 2, "num_frames": 256}}' \  --block-size 64 \  --prefix-match-unit 64 \  --enable-auto-tool-choice \  --tool-call-parser qwen3_coder \  --reasoning-parser nemotron_v3

Wait for the server to finish loading the model and compiling kernels, then check the endpoint:

bash

curl --fail http://localhost:8000/v1/models

All vLLM and SGLang examples use port 8000 and the API model name nemotron-3.5-super-vl. See the API Client for text, image, video, and tool-calling examples.

License/Terms of Use

Governing Download Terms: Use of this model is governed by the OpenMDW License Agreement, version 1.1.

Benchmarks

We evaluated our model on the following benchmarks:

Table with columns: Benchmark, Nemotron 3.5 Super VL BF16, Nemotron 3.5 Super VL NVFP4
Benchmark	Nemotron 3.5 Super VL BF16	Nemotron 3.5 Super VL NVFP4
GPQA-Diamond	89.52	89.90
HLE, text-only	31.79	31.44
MMLU-ProX	76.91	73.76
AA-Omniscience accuracy	26.20	25.86
AA-Omniscience hallucination rate	30.0	27.7
AA-Omniscience index	4.03

The evaluations between the BF16 checkpoint and NVFP4 checkpoint are done with all configs, harnesses, and other non-model parameters held static to ensure fair comparison that isolates the checkpoint impact

Agentic Coding Benchmarks

Additional harness-level coding-agent results for SWE-Bench Pro and Terminal-Bench 2.1 are shown below.

Deployment Geography: Global

Use Case

Release Date

Hugging Face - 10/15/2026 via Hugging Face

Reference(s)

NVIDIA Nemotron 3.5 Super VL and Lightning Technical Report

Model Architecture

Architecture Type: Mamba-2–Transformer hybrid Mixture of Experts (MoE) with Multi-Token Prediction (MTP)
Network Architecture: Nemotron Hybrid MoE with 512 routed experts per MoE layer, a C-RADIO vision encoder, and a vision-language connector
Number of Model Parameters: 120B total / 12B active

Model Design

Training Methodology

Stage 1: Foundation and Multi-Token Prediction

Stage 2: Continued Pre-Training and Mid-Training

Stage 3: Vision-Language Training

A C-RADIO vision encoder and connector extend the language backbone to visual inputs, including images, document pages, and video frames.

Stage 4: Supervised Fine-Tuning

Stage 5: Reinforcement Learning and Distillation

Stage 6: MTP Boosting

The MTP head is further trained against the frozen post-trained backbone to improve speculative-decoding acceptance.

Stage 7: Quantization and Quantization-Aware Distillation

Input

Input Type(s): Text, images, and video
Input Format(s): Text strings, images, and sampled video frames
- Video: mp4, up to 2 minutes.
- Image: Red, Green, Blue (RGB) (jpeg, png)
Input Parameters:
- Video: Three-Dimensional (3D)
- Image: Two-Dimensional (2D)
- Text: One-Dimensional (1D)
Other Properties Related to Input: Maximum context length up to 1M tokens. Documents can be supplied as page images with accompanying text.

Output

Output Type(s): Text
Output Format: String
Output Parameters: One-dimensional sequences
Other Properties Related to Output: Input and output tokens share the configured context window.

Software Integration

Runtime Engine(s): vLLM; SGLang; TensorRT-LLM
Hardware:
- NVIDIA Blackwell
- NVIDIA Hopper
Operating System(s): Linux

Model Version(s)

v1.0 - NVFP4 GA

Quick Start Guide

Choose your deployment

Table with columns: Hardware, Runtime, Configuration
Hardware	Runtime	Configuration
1× DGX Spark	vLLM	Text, image; 1M-token context; MTP with 5 draft tokens
2× H100	vLLM	Text, image, and video; 1M-token context; MTP with 3 draft tokens
1× H200	vLLM	Text, image, and video; 1M-token context; MTP with 3 draft tokens
1× GB200	vLLM	Text, image, and video; 1M-token context; MTP with 5 draft tokens
1× GB200 or 2× H100	SGLang	Text, image; 1M-token context; MTP with 5 draft steps

NIM and Dynamo

For production workloads, leverage our best-in-class deployment solutions:

Running on Local Hardware

For Local inference on DGX Spark, RTX Spark, and RTX Pro 6000 you can find details on running the model through the following libraries:

llama.cpp available here
Unsloth available here

Speculative Decoding

vLLM

Use vllm/vllm-openai:nightly-3f1bcfd82bb2e93fcd364fc7a5491718453a77e2 for these commands (or vllm/vllm-openai:v0.32.0).

2× H100 (up to 1M Context Length)

Use this command if you need to serve the model with up to 1M context length.

bash

vllm serve $MODEL \  --served-model-name nemotron-3.5-super-vl \  --tensor-parallel-size 2 \  --max-num-seqs 128 \  --trust-remote-code \  --gpu-memory-utilization 0.89 \  --max-num-batched-tokens 16384 \  --block-size 64 \  --prefix-match-unit 64 \  --compilation_config.max_cudagraph_capture_size 256 \  --mamba-backend flashinfer \  --mamba-ssm-cache-dtype float16 \  --enable-mamba-cache-stochastic-rounding \  --mamba-cache-philox-rounds 5 \  --enable-mamba-shared-prefix-checkpoint \  --mamba-cache-mode align \  --speculative-config.method mtp \  --speculative-config.num_speculative_tokens 3 \  --video-pruning-rate 0.5 \  --media-io-kwargs '{"video": {"fps": 2, "num_frames": 256}}' \  --enable-auto-tool-choice \  --tool-call-parser qwen3_coder \  --reasoning-parser nemotron_v3

For one H200, use the same command with --tensor-parallel-size 1.

1× GB200 (up to 1M Context Length)

Use this command if you need to serve the model with up to 1M context length.

bash

vllm serve $MODEL \  --served-model-name nemotron-3.5-super-vl \  --trust-remote-code \  --max-num-seqs 512 \  --enable-prefix-caching \  --max-num-batched-tokens 32768 \  --prefix-match-unit 16 \  --enable-mamba-shared-prefix-checkpoint \  --async-scheduling \  --kernel-config '{"linear_backend_per_quant":{"fp8_w8a8":"torch"}}' \  --compilation-config '{"pass_config":{"fuse_attn_quant":true},"use_inductor_graph_partition":true,"cudagraph_mode":"FULL_AND_PIECEWISE"}' \  --mamba-backend flashinfer \  --mamba-ssm-cache-dtype float16 \  --enable-mamba-cache-stochastic-rounding \  --mamba-cache-philox-rounds 5 \  --mamba-cache-mode align \  --video-pruning-rate 0.5 \  --media-io-kwargs '{"video": {"fps": 2, "num_frames": 256}}' \  --enable-auto-tool-choice \  --speculative_config.method mtp \  --speculative_config.num_speculative_tokens 5 \  --tool-call-parser qwen3_coder \  --reasoning-parser nemotron_v3

SGLang

Use lmsysorg/sglang:v0.5.20. The example below runs on one GB200 GPU. For two H100 GPUs, add --tp-size 2.

bash

docker run --rm --gpus all --ipc=host \  -p 8000:8000 \  -e HF_TOKEN \  -v "$HOME/.cache/huggingface:/root/.cache/huggingface" \  --entrypoint sglang lmsysorg/sglang:v0.5.20 \      serve --model-path "$MODEL_CKPT" \  --served-model-name nemotron-3.5-super-vl \  --host 0.0.0.0 \  --port 8000 \  --trust-remote-code \  --mamba-backend flashinfer \  --reasoning-parser nemotron_3 \  --tool-call-parser qwen3_coder \  --mamba-ssm-dtype float16 \  --enable-mamba-cache-stochastic-rounding \  --mamba-cache-philox-rounds 5 \  --speculative-algorithm EAGLE \  --speculative-num-steps 5 \  --speculative-eagle-topk 1

TensorRT-LLM

The following configurations use TensorRT-LLM 1.3.0rc28, built from commit 55f7eca861613bd60e1ac34d5916f091cd89d558 with Python 3.12 and the Mamba cache patch.

Download the NVFP4 checkpoint locally:

bash

hf download "$MODEL_CKPT" --local-dir ./models/super-vl-nvfp4

1× GB200

Save the following as super-vl-gb200.yaml:

yaml

tensor_parallel_size: 1moe_expert_parallel_size: 1trust_remote_code: trueenable_chunked_prefill: truedisable_overlap_scheduler: falsemax_batch_size: 16max_num_tokens: 8192max_seq_len: 1048576attn_backend: TRTLLMmoe_config:  backend: TRTLLMkv_cache_config:  dtype: fp8  tokens_per_block: 32  mamba_ssm_cache_dtype: float16  mamba_ssm_stochastic_rounding: false  free_gpu_memory_fraction: 0.85  enable_block_reuse: true  mamba_state_config:    periodic_snapshot_interval: 0    additional_snapshot_offsets_from_start: [50016]    additional_snapshot_offsets_from_end: [0]    enable_branch_snapshot: truecuda_graph_config:  enable_padding: true  batch_sizes: [1, 2, 4, 8, 12, 16]speculative_config:  decoding_type: MTP  max_draft_len: 5guided_decoding_backend: xgrammar

tensor_parallel_size: 1moe_expert_parallel_size: 1trust_remote_code: trueenable_chunked_prefill: truedisable_overlap_scheduler: falsemax_batch_size: 16max_num_tokens: 8192max_seq_len: 1048576attn_backend: TRTLLMmoe_config:  backend: TRTLLMkv_cache_config:  dtype: fp8  tokens_per_block: 32  mamba_ssm_cache_dtype: float16  mamba_ssm_stochastic_rounding: false  free_gpu_memory_fraction: 0.85  enable_block_reuse: true  mamba_state_config:    periodic_snapshot_interval: 0    additional_snapshot_offsets_from_start: [50016]    additional_snapshot_offsets_from_end: [0]    enable_branch_snapshot: truecuda_graph_config:  enable_padding: true  batch_sizes: [1, 2, 4, 8, 12, 16]speculative_config:  decoding_type: MTP  max_draft_len: 5guided_decoding_backend: xgrammar

bash

trtllm-serve ./models/super-vl-nvfp4 \  --config super-vl-gb200.yaml \  --served_model_name nemotron-3.5-super-vl \  --host 0.0.0.0 \  --port 8000 \  --tool_parser qwen3_coder \  --reasoning_parser nemotron-v3

max_seq_len sets the context limit; max_num_tokens controls the token batch size. For TensorRT-LLM clients, use the model identifier returned by /v1/models.

1× DGX Spark

Save the following as super-vl-gb200.yaml:

yaml

trust_remote_code: truedtype: bfloat16tensor_parallel_size: 1moe_expert_parallel_size: 1max_batch_size: 2max_num_tokens: 4096max_seq_len: 131072 enable_chunked_prefill: truedisable_overlap_scheduler: falsecuda_graph_config: nullattn_backend: TRTLLM kv_cache_config:  dtype: fp8  free_gpu_memory_fraction: 0.9  max_gpu_total_bytes: 5368709120  host_cache_size: 0  mamba_ssm_cache_dtype: float16  mamba_ssm_stochastic_rounding: false  enable_block_reuse: true  use_kv_cache_manager_v2: true  mamba_state_config:    enable_branch_snapshot: true nvfp4_gemm_config:  allowed_backends: [cutlass, cublaslt, cuda_core] moe_config:  backend: CUTEDSL speculative_config:  decoding_type: DFlash  speculative_model: ./models/super-vl-lilicorr  max_draft_len: 7  attention_backend: TRTLLM  context_recompute_tail: 0 guided_decoding_backend: xgrammar

trust_remote_code: truedtype: bfloat16tensor_parallel_size: 1moe_expert_parallel_size: 1max_batch_size: 2max_num_tokens: 4096max_seq_len: 131072 enable_chunked_prefill: truedisable_overlap_scheduler: falsecuda_graph_config: nullattn_backend: TRTLLM kv_cache_config:  dtype: fp8  free_gpu_memory_fraction: 0.9  max_gpu_total_bytes: 5368709120  host_cache_size: 0  mamba_ssm_cache_dtype: float16  mamba_ssm_stochastic_rounding: false  enable_block_reuse: true  use_kv_cache_manager_v2: true  mamba_state_config:    enable_branch_snapshot: true nvfp4_gemm_config:  allowed_backends: [cutlass, cublaslt, cuda_core] moe_config:  backend: CUTEDSL speculative_config:  decoding_type: DFlash  speculative_model: ./models/super-vl-lilicorr  max_draft_len: 7  attention_backend: TRTLLM  context_recompute_tail: 0 guided_decoding_backend: xgrammar

bash

trtllm-serve ./models/super-vl-nvfp4 \  --config super-vl-spark-lilicorr.yaml \  --served_model_name nemotron-3.5-super-vl \  --host 0.0.0.0 \  --port 8000 \  --reasoning_parser nemotron-v3

API Client

Install the OpenAI-compatible client:

bash

pip install openai

Text and reasoning

python

from openai import OpenAI client = OpenAI(base_url="http://localhost:8000/v1", api_key="EMPTY")model = "nemotron-3.5-super-vl" response = client.chat.completions.create(    model=model,    messages=[{"role": "user", "content": "Explain why binary search takes logarithmic time."}],    temperature=1.0,    top_p=0.95,    max_tokens=16384,    extra_body={"chat_template_kwargs": {"enable_thinking": True}},)choice = response.choices[0]if choice.finish_reason == "length":    raise RuntimeError("The response reached max_tokens; increase the output budget.")print(choice.message.content)

Images

Use a multimodal server configuration. The example below sends a local image as a base64 data URL.

python

import base64from pathlib import Pathfrom openai import OpenAI client = OpenAI(base_url="http://localhost:8000/v1", api_key="EMPTY")image_bytes = Path("image.png").read_bytes()image_url = "data:image/png;base64," + base64.b64encode(image_bytes).decode() response = client.chat.completions.create(    model="nemotron-3.5-super-vl",    messages=[{"role": "user", "content": [        {"type": "text", "text": "Describe the image and any visible text."},        {"type": "image_url", "image_url": {"url": image_url}},    ]}],    temperature=1.0,    top_p=0.95,    max_tokens=16384,)if response.choices[0].finish_reason == "length":    raise RuntimeError("The response reached max_tokens; increase the output budget.")print(response.choices[0].message.content)

Video with vLLM

Use a multimodal vLLM configuration with the video sampling settings above.

python

import base64from pathlib import Pathfrom openai import OpenAI client = OpenAI(base_url="http://localhost:8000/v1", api_key="EMPTY")video_bytes = Path("video.mp4").read_bytes()video_url = "data:video/mp4;base64," + base64.b64encode(video_bytes).decode() response = client.chat.completions.create(    model="nemotron-3.5-super-vl",    messages=[{"role": "user", "content": [        {"type": "text", "text": "Summarize the events in this video in order."},        {"type": "video_url", "video_url": {"url": video_url}},    ]}],    temperature=1.0,    top_p=0.95,    max_tokens=16384,)if response.choices[0].finish_reason == "length":    raise RuntimeError("The response reached max_tokens; increase the output budget.")print(response.choices[0].message.content)

Tool calling

The model requests a tool call; the application executes it and returns the result. This complete example uses a local inventory lookup.

python

import jsonfrom openai import OpenAI client = OpenAI(base_url="http://localhost:8000/v1", api_key="EMPTY")model = "nemotron-3.5-super-vl"inventory = {"keyboard": 12, "monitor": 5}tools = [{"type": "function", "function": {    "name": "get_inventory",    "description": "Return the inventory count for a product.",    "parameters": {        "type": "object",        "properties": {"product": {"type": "string", "enum": ["keyboard", "monitor"]}},        "required": ["product"],        "additionalProperties": False,    },}}]messages = [{"role": "user", "content": "How many keyboards are in stock?"}] def complete(history, tool_choice="auto"):    response = client.chat.completions.create(        model=model,        messages=history,        tools=tools,        tool_choice=tool_choice,        temperature=1.0,        top_p=0.95,        max_tokens=16384,        extra_body={"chat_template_kwargs": {"enable_thinking": True}},    )    choice = response.choices[0]    if choice.finish_reason == "length":        raise RuntimeError("The response was truncated; increase max_tokens.")    return choice.message message = complete(messages)messages.append(message.model_dump(exclude_none=True))if not message.tool_calls:    print(message.content)else:    for call in message.tool_calls:        arguments = json.loads(call.function.arguments)        if (call.function.name != "get_inventory"                or not isinstance(arguments, dict)                or set(arguments) != {"product"}                or not isinstance(arguments["product"], str)                or arguments["product"] not in inventory):            raise ValueError("Invalid inventory tool call")        product = arguments["product"]        messages.append({            "role": "tool",            "tool_call_id": call.id,            "content": json.dumps({"product": product, "count": inventory[product]}),        })    print(complete(messages, tool_choice="none").content)

Training, Testing, and Evaluation Datasets

Training

For more information about the datasets used to train this model, please see the Public Summary of Training Content

Base Pre-Training Corpus (Nemotron 3 Foundation)

The foundation of the model is trained on the Nemotron 3 corpus, comprising the following datasets from the Nemotron Pretraining Datasets collection:

Table with columns: Dataset Collection, Token Counts, Description
Dataset Collection	Token Counts	Description
Nemotron-CC-v2 & v2.1	9.1T	A massive collection of English web data filtered from Common Crawl, including 2.5T+ tokens of new organic, translated, and synthetically rephrased content.
Nemotron-CC-Code-v1	427.9B	High-quality code tokens extracted from Common Crawl using the Lynx + LLM pipeline to preserve structure and equations.
Nemotron-Pretraining-Code-v1 & v2 & v3	1.7T	Curated GitHub code references with multi-stage filtering, deduplication, and large-scale synthetic code data.
Nemotron-CC-Math-v1	133.3B	High-quality math pre-training dataset preserving LaTeX formatting and mathematical structures.

Public Datasets

Table with columns: Dataset, Collection Period
Dataset	Collection Period
GSM8K	4/23/2025
CC-NEWS	4/23/2025
Common Crawl	4/23/2025
Wikimedia	4/23/2025
Bespoke-Stratos-17k

Crawled and Scraped from Online Sources by NVIDIA

Table with columns: Dataset, Modality, Dataset Size, Collection Period, Collecting Organisation
Dataset	Modality	Dataset Size	Collection Period	Collecting Organisation
English Common Crawl	Text	3.36T	4/8/2025	NVIDIA Advanced Deep Learning Research
English Common Crawl 1.1	Text	Not disclosed	10/2/2025	NVIDIA Advanced Deep Learning Research
Multilingual Common Crawl	Text	812.7B	5/1/2025

Private Non-publicly Accessible Datasets of Third Parties

Table with columns: Dataset, Model(s) used
Dataset	Model(s) used
Global Regulation	Unknown
TAUS Translation Memory	Unknown
Scale HLE	Unknown
HackerRank Coding	Unknown
RL data for Search	Gemini 3; GPT-5
Mercor SWE-AgentsV1	Undisclosed
KeenSight Batch 1, Relabeled Subset	Qwen3.5-122B-A10B
KeenSight Batch 1, Remaining Subset	Qwen3.5-122B-A10B
Camio Multilingual OCR and Document Layout

Private Non-publicly Accessible Datasets by NVIDIA

Table with columns: Dataset, Model(s) used
Dataset	Model(s) used
Simple Minesweeper	Undisclosed
Simple Sudoku	Undisclosed
Multitool Typewriter Hard	Undisclosed
Machine Translation of News Commentary and TAUS Translation Memory	Undisclosed
Machine Translation of STEM -	Qwen2.5-14B-Instruct
Competitive Coding RL data from Nemotron Cascade	Undisclosed
Long context RL	Undisclosed
Single-step SWE RL for patch generation

NVIDIA-Sourced Synthetic Datasets (Pre-Training)

Table with columns: Dataset, Modality, Dataset Size, Seed Dataset, Model(s) used for generation
Dataset	Modality	Dataset Size	Seed Dataset	Model(s) used for generation
Nemotron-Pretraining-Fact-Seeking	Text	35.0B	FineWiki	Qwen3-30B-A3B-Instruct-2507
Nemotron-Pretraining-Legal	Text	4.3B	CommonPile (caselaw_access_project_filtered); California Code of Regulations; Judicial Ethics Opinions; GLOBALCIT; ; Nemotron Personas; ; CodeHima/TOS_Dataset; ; CaseHOLD; Code of Federal Regulations; (subsets that allow commercial use)

NVIDIA-Sourced Synthetic Datasets (Post-Training)

Table with columns: Dataset, Modality, Dataset Size, Seed Dataset, Model(s) used for generation
Dataset	Modality	Dataset Size	Seed Dataset	Model(s) used for generation
Synthetic Single-Step Tool Use — RL	Text	Approximately 1,433,203 samples	Handwritten prompts; no external seed data	DeepSeek-V3.2; DeepSeek-R1-0528; Qwen3-235B-A22B-Thinking-2507; Qwen3-32B
Synthetic Sparse Tables with Mixed Prompts	Text and images	100,000 records	Generated in-house; no external seed data	None; generated without an SDG model
Synthetic Single-Step Tool Use — RL	Text	Approximately 1,433,203 samples

Language Distribution in Post-Training

Additional Training Data

Table with columns: Data, Composition and Purpose
Data	Composition and Purpose
Indic continued pre-training	100B tokens: 10B selected Indic tokens and 90B tokens from the preceding blend.
Software-engineering mid-training	67B tokens: whole repositories (20%), issue–pull-request pairs (41%), commit diffs (3%), build and CI logs (1%), agent traces (10%), pre-training replay (20%), and long-context data (5%). Sources are decontaminated against SWE-bench and Terminal-Bench repositories.
Long-context pre-training	A 35B-token extension to 1M context, followed by a 9B-token long-context recovery stage.
Vision-language data	Image and video data from the Nemotron 3 Nano Omni training corpus, including visual question answering, charts, tables, OCR, multi-page documents, visual grounding, and video understanding.

Table with columns: Post-Training Data, Composition and Purpose
Post-Training Data	Composition and Purpose
Additional synthetic vision data	Chart understanding, grounded perception, multimodal reasoning, and visual tool-use trajectories, including data generated with Qwen3.5 and Kimi models.
Reasoning trajectories	Mathematics and STEM responses generated with Kimi K3; mathematical proofs generated with DeepSeek V4 Pro; competitive-programming trajectories generated with GLM-5.2.
Chat and safety	Refreshed chat responses from Qwen, Kimi, and Gemma models, with additional safety data.
Long-context supervised data	512K-context data, synthetic graph reasoning and transduction tasks, long-horizon search and coding trajectories, and documents containing up to hundreds of pages.
Long-document translation	Chunked translations of PG19 and FinePDFs-Edu documents generated with DeepSeek V4 Flash.

Testing Datasets

Evaluation Datasets

Inference

Acceleration Engine: PyTorch
Test Hardware:
- NVIDIA Hopper
  - H100
  - H200
- NVIDIA Grace Blackwell
  - GB200
  - GB300
- NVIDIA Blackwell
  - B200
  - B300

Ethical Considerations

Please report model quality, risk, security vulnerabilities or NVIDIA AI Concerns here.

NVIDIA-Nemotron-3.5-Super-VL-120B-A12B-NVFP4

README

Description

Model Summary

Model Overview

What is Nemotron?

Quick Start

License/Terms of Use

Benchmarks

Agentic Coding Benchmarks

Deployment Geography: Global

Use Case

Release Date

Reference(s)

Model Architecture

Model Design

Training Methodology

Input

Output

Software Integration

Model Version(s)

Quick Start Guide

Choose your deployment

NIM and Dynamo

Running on Local Hardware

Speculative Decoding

vLLM

2× H100 (up to 1M Context Length)

1× GB200 (up to 1M Context Length)

SGLang

TensorRT-LLM

1× GB200

1× DGX Spark

API Client

Text and reasoning

Images

Video with vLLM

Tool calling

Training, Testing, and Evaluation Datasets

Training

Base Pre-Training Corpus (Nemotron 3 Foundation)

Public Datasets

Crawled and Scraped from Online Sources by NVIDIA

Private Non-publicly Accessible Datasets of Third Parties

Private Non-publicly Accessible Datasets by NVIDIA

NVIDIA-Sourced Synthetic Datasets (Pre-Training)

NVIDIA-Sourced Synthetic Datasets (Post-Training)

Language Distribution in Post-Training

Additional Training Data

Testing Datasets

Evaluation Datasets

Inference

Ethical Considerations

Explore FriendliAI today

README

Description

Model Summary

Model Overview

What is Nemotron?

Quick Start

License/Terms of Use

Benchmarks

Agentic Coding Benchmarks

Deployment Geography: Global

Use Case

Release Date

Reference(s)

Model Architecture

Model Design

Training Methodology

Input

Output

Software Integration

Model Version(s)

Quick Start Guide

Choose your deployment

NIM and Dynamo

Running on Local Hardware

Speculative Decoding

vLLM