NVIDIA-Nemotron-3.5-Super-VL-120B-A12B — NIM model artifacts

Description

NVIDIA-Nemotron-3.5-Super-VL-120B-A12B is a vision-language model (VLM) trained by NVIDIA. This repository holds the model artifacts consumed by the NVIDIA Nemotron 3.5 Super VL NIM (2.0.13): the BF16 weights and the NVFP4 weights. The NIM selects the version that matches the GPU profile it runs.

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 available for commercial and non-commercial use under the OpenMDW-1.1 license.

For more details on how to deploy and use the model — see the Quick Start Guide below!

Versions in This Repository

Each version ships a checksums.blake3 file. Other versions in this repository are earlier pre-release builds and are not used by the 2.0.13 NIM.

Model Summary

Speculative Decoding

Speculative decoding is lossless: verified tokens are identical to non-speculative decoding.

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.

License/Terms of Use

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

Benchmarks

Agentic Coding Benchmarks

The following results evaluate the post-trained Nemotron 3.5 Super model.

These are the highest scores across six evaluated agent harnesses, using their standard configurations and unmodified system prompts. For SWE-bench Pro, Git history is removed and the user instruction prohibits seeking online resources. Results depend on the harness and its configuration.

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 BF16 and Hugging Face NVFP4

Reference(s)

• NVIDIA Nemotron 3 model family on Hugging Face
• NVIDIA Nemotron 3 Ultra 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.

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: One-Dimensional (1D): Sequences
• 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: Maximum context length up to 1M tokens.

Our AI models are designed and/or 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 (NVIDIA NIM)
• Supported Hardware Microarchitecture Compatibility: NVIDIA Ampere - A100-80GB; NVIDIA Blackwell - B200, GB200, B300, GB300, RTX Pro 6000 Blackwell Server Edition, DGX Station, DGX Spark; NVIDIA Hopper - H100, H200
• Preferred/Supported 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)

• bf16-ga-20261003 (10/03/2026)
• nvfp4-ga-20261003 (10/03/2026)

Quick Start Guide

These artifacts are downloaded and served by the NVIDIA Nemotron 3.5 Super VL NIM; you do not need to download them manually. Set NIM_IMAGE to the NIM container image for the release.

export NGC_API_KEY=<your NGC API key>
export NIM_IMAGE=<NIM container image>
export LOCAL_NIM_CACHE=~/.cache/nim
mkdir -p "$LOCAL_NIM_CACHE"

1. List the profiles and pick the one for your GPU. Pin it with NIM_MODEL_PROFILE; automatic selection is not reliable across GPU SKUs.

docker run --rm --gpus all -e NGC_API_KEY $NIM_IMAGE list-model-profiles

2. Start the NIM.

docker run -it --rm --gpus all --shm-size=16GB \
  -e NGC_API_KEY \
  -e NIM_MODEL_PROFILE=<profile id from step 1> \
  -e NVIDIA_DRIVER_CAPABILITIES=compute,utility,video \
  -v "$LOCAL_NIM_CACHE:/opt/nim/.cache" \
  -p 8000:8000 \
  $NIM_IMAGE

NVIDIA_DRIVER_CAPABILITIES must include video so the NIM can decode video on the GPU (NVDEC).

3. Check readiness.

curl -s http://localhost:8000/v1/health/ready
curl -s http://localhost:8000/v1/models

API Client

The examples below use the OpenAI-compatible client against the NIM endpoint. Recommended sampling settings are temperature 1.0, top_p 0.95 for text and temperature 0.6, top_p 0.95 for image and video.

Copy the identifier returned by GET /v1/models into MODEL below.

from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="EMPTY")
MODEL = "model"  # replace with the identifier returned by GET /v1/models

NVIDIA Nemotron 3.5 Super VL exposes reasoning control through chat-template kwargs: thinking enabled (the default), and thinking disabled for direct answers. With the OpenAI SDK these are passed via extra_body, not as top-level arguments.

response = client.chat.completions.create(
    model=MODEL,
    messages=[{"role": "user", "content": "Hello, what can you do?"}],
    max_tokens=16000,
    temperature=1.0,
    top_p=0.95,
)
print(response.choices[0].message.content)

Hello! I am an AI assistant designed to help you with a wide variety of tasks. Here are some of the things I can do:

*   **Answer Questions:** I can provide information on a vast range of topics, from science and history to current events and general knowledge.
*   **Writing & Editing:** I can help write emails, essays, poems, scripts, or articles. I can also proofread and improve your existing text.
*   **Coding & Tech Support:** I can help write code in various programming languages, debug errors, and explain technical concepts.
*   **Summarization:** I can condense long articles, documents, or videos into key points.
*   **Translation:** I can translate text between many different languages.
*   **Brainstorming:** I can help generate ideas for projects, business names, gifts, or creative endeavors.
*   **Math & Logic:** I can solve mathematical problems and work through logic puzzles.

Is there something specific you would like help with today?

import base64

def image_to_data_url(path: str) -> str:
    with open(path, "rb") as f:
        b64 = base64.b64encode(f.read()).decode("utf-8")
    return f"data:image/jpeg;base64,{b64}"

response = client.chat.completions.create(
    model=MODEL,
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "image_url", "image_url": {"url": image_to_data_url("your_image.jpg")}},
                {"type": "text", "text": "Describe this image."},
            ],
        }
    ],
    max_tokens=16000,
    temperature=0.6,
    top_p=0.95,
    extra_body={"chat_template_kwargs": {"enable_thinking": False}},
)
print(response.choices[0].message.content)

The image shows a capybara in a zoo enclosure. The capybara is eating green leafy vegetables on the ground. Its enclosure has a dirt floor and a large hollowed-out log behind it. There's a concrete wall visible, with trees and bushes beyond it. The capybara is facing right, with its head down as it eats. The scene is well-lit, suggesting it's daytime. The image captures a natural moment of the capybara's daily life in its zoo habitat.

import base64

def video_to_data_url(path: str) -> str:
    with open(path, "rb") as f:
        b64 = base64.b64encode(f.read()).decode("utf-8")
    return f"data:video/mp4;base64,{b64}"

response = client.chat.completions.create(
    model=MODEL,
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "video_url", "video_url": {"url": video_to_data_url("your_video.mp4")}},
                {"type": "text", "text": "Describe what happens in this video."},
            ],
        }
    ],
    max_tokens=16000,
    temperature=0.6,
    top_p=0.95,
    extra_body={"chat_template_kwargs": {"enable_thinking": False}},
)
print(response.choices[0].message.content)

The video shows a rotating view of Earth from space, highlighting the illuminated areas of the planet against the dark backdrop of space. The continents and oceans are visible, with city lights indicating populated regions. The rotation provides a dynamic perspective of the Earth's surface, showcasing its curvature and the distribution of light across different landmasses.

PDF input: The API accepts images, not raw PDF files. Render each page to PNG (e.g. with pymupdf) and send it as a base64 image_url as in the Image example above.

Recommended Media Inputs

Video

Use MP4 files of 1–2 minutes. Every NIM profile samples at 2 FPS, up to 256 frames, with Efficient Video Sampling (pruning rate 0.5), which covers roughly two minutes of footage. Longer clips are truncated to 256 frames.

Images

Tested input configurations:

Each page image counts toward the prompt side of the context length.

Notes

1. Video container and length: MP4, 1–2 minutes. Other containers are untested.
2. Video decoding needs NVDEC access: start the container with NVIDIA_DRIVER_CAPABILITIES=compute,utility,video.
3. max_tokens vs context length: max_tokens caps only the completion. Prompt plus completion must fit inside the profile's context length, and video prefill consumes a large share of it.

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 Nemotron 3.5 Super VL EU Training Content Summary.

Additional Training Data

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

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.

Inference

• Acceleration Engine: vLLM (NVIDIA NIM)
• Test Hardware:
  • NVIDIA Ampere
    • 2x A100-80GB
  • NVIDIA Blackwell
    • 1-2x B200, 1-2x GB200
    • 1-2x B300, 1-2x GB300
    • 2x RTX Pro 6000 Blackwell Server Edition
    • DGX Station
    • DGX Spark
  • NVIDIA Hopper
    • 2-8x H100
    • 1-4x H200

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.

Get Help

NVIDIA Developer Community Forum

Get access to community knowledge base articles and support cases (https://forums.developer.nvidia.com/)

Enterprise Support

Get access to knowledge base articles and support cases or submit a ticket.