NVIDIA-Nemotron-3.5-Super-VL

NVIDIA Nemotron 3.5 Super VL

An open multimodal model for agents that see, reason, and act. 120 billion parameters, 12 billion active.

Released 15 October 2026 — version 1.0, general availability.

One Model for Text, Images, Documents, Interfaces, and Video

Nemotron 3.5 Super VL reads text, images, document pages, and video, and adds reasoning and tool use on top — a single model for agents that have to look at something before they act on it.

Output is text.

Interfaces are part of the claim. The model is evaluated on OSWorld-Verified, a benchmark of agents operating real desktop software — reading a screen and deciding what to do next. That is vision and action in one loop, and it is the use the model is named for.

Documents arrive as images. A scanned contract, a financial filing, or a slide deck is supplied page by page, with any extracted text alongside — so layout, tables, and figures are read as they appear rather than flattened.

Twelve Billion Active, in Three Kinds of Layer

Three layer types are interleaved: Mamba-2 state-space layers, attention layers, and mixture-of-experts layers.

Each does a different job. Mamba-2 layers carry sequence state at constant cost however long the input grows. Attention layers provide exact retrieval across the sequence. Expert layers supply capacity — 512 routed experts per layer, of which a small fraction runs for any given token.

That combination is what keeps long, image-heavy agent sessions affordable. Most of the depth does not grow a cache as the conversation lengthens.

The vision path is separate and joins early. A C-RADIO encoder turns each image or video frame into representations, and a connector hands them to the language backbone, which reasons over them alongside text.

Built on Its Larger Sibling

The training recipe is published in six stages, and the first one explains a great deal.

Stage 1 — foundation and multi-token prediction. The language backbone starts from Nemotron 3 Super Base. A shared multi-token-prediction head is trained for 100 billion tokens with the backbone frozen, followed by one trillion tokens of distillation from Nemotron 3 Ultra Base — NVIDIA's largest model in the family.

Stage 2 — continued pre-training and mid-training. 100 billion tokens of Indic continued pre-training; a 35-billion-token extension to one-million-token context; 67 billion tokens of software-engineering mid-training at 256K context; and a final 9-billion-token long-context recovery stage.

Stage 3 — vision-language training. The C-RADIO encoder and connector extend the backbone to images, document pages, and video frames.

Stage 4 — supervised fine-tuning. Two stages, jointly training language and vision components on vision, reasoning, code, tools, chat, safety, and long-context data, with packed sequences of up to 524,288 tokens.

Stage 5 — reinforcement learning and distillation. RL with verifiable rewards, RL from human feedback, and specialised teacher training — then multi-teacher on-policy distillation to consolidate them into one model.

Stage 6 — MTP boosting. The multi-token-prediction head is trained again against the frozen, finished model, specifically to raise how often its drafted tokens are accepted.

What the software-engineering data contains

Repositories, issue and pull-request pairs, commit diffs, build and CI logs, and agent trajectories.

That list is the interesting part. A model trained on finished code learns what code looks like. A model trained on the pull request that fixed an issue, the diff that changed it, and the CI log that failed before it passed learns how code changes — which is the work an agent actually does.

And NVIDIA describe the result as comparable to their largest reasoning model at roughly one-fifth the parameter count. A trillion tokens of distillation is how that kind of gap is closed.

Reasoning: On by Default, Off on Request

Reasoning runs by default. A request with no reasoning setting returns a reasoning trace in its own field, separate from the answer.

Two ways to turn it off, with the same result:

extra_body={"reasoning_effort": "none"}
extra_body={"chat_template_kwargs": {"enable_thinking": False}}

And a documented medium mode between full reasoning and none:

extra_body={"chat_template_kwargs": {"enable_thinking": True, "medium_effort": True}}

Reasoning tokens are reported separately in the usage object — so you can see exactly what deliberation cost on each request, and measure whether turning it on earned its tokens.

Reasoning and answer share the max_tokens budget. With reasoning on, a ceiling sized for the answer alone can end the response before the answer appears — check finish_reason.

Because the default is on, turn it off deliberately. Classification, routing, and extraction against a fixed schema have one correct answer; a reasoning pass adds latency and tokens to every call unless you prevent it.

Two Sampling Settings, by Input

NVIDIA publish different recommendations for text and for vision:

Read the lower vision temperature as deliberate. Describing what is in an image, reading a table off a page, or transcribing visible text has one correct answer far more often than open-ended text does — and less sampling variance is less invented detail.

Switch on the request, not globally. An agent that alternates between reading a screenshot and planning a next step should use 0.6 for the first and 1.0 for the second.

The Window

262,144 tokens.

The architecture supports up to one million. NVIDIA's own card notes that individual deployments may use a smaller window to fit available memory and concurrency; the window served here is 262,144.

Everything shares it — the prompt, images and video frames, conversation history, tool results, reasoning, and the response.

Visual input is not free. Every image and every sampled video frame becomes tokens inside that window. A long agent session full of screenshots fills it faster than its text alone would suggest.

Design around 262,144, not the architectural figure. A request built for a million tokens fails here.

Benchmarks

Published by NVIDIA, collected through NeMo Gym, with reproducibility recipes released alongside — containers, prompts, inference parameters, parsers, and scoring settings.

Reasoning and knowledge

Agentic and coding

Vision, documents, and video

Long context

Hallucination

The hallucination rate is the number worth reading first. It measures how often a model answers confidently when it should have declined — and at 30.0, it sits among the lowest in NVIDIA's own comparison table. For an agent that acts on its own conclusions, a model that knows when it does not know matters more than one more point of accuracy.

GraphWalks at 89.71 is the highest figure in the comparison. It tests following relationships across a long context, which is what an agent does when it traces a dependency through a large codebase.

Where it is weaker

The same table reports its weak spots, and they are worth knowing:

MMLU-ProX at 76.91 — the lowest in the comparison on that benchmark.

tau3-bench banking at 18.88, AutomationBench at 32.44, and Terminal Bench 4 at 1 — the hardest long-horizon agent evaluations, where every model in the table struggles and this one more than most.

Read the profile as specialised rather than general. Strong on vision, long-context retrieval, science reasoning, and low hallucination; less strong on the most demanding multi-hour agent tasks.

Specifications

Ready for commercial or non-commercial use, under the OpenMDW License Agreement, version 1.1.

Two official releases. A BF16 checkpoint for customisation, domain adaptation, and full-precision evaluation — and an NVFP4 checkpoint for efficient deployment, produced with quantisation-aware distillation from the BF16 model rather than by rounding its weights after the fact.

Capabilities

Using Nemotron 3.5 Super VL on DEVUP AI

Base URL: https://api.devupai.com/v1 · Model ID: nvidia/NVIDIA-Nemotron-3.5-Super-VL

Python

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["DEVUP_API_KEY"],
    base_url="https://api.devupai.com/v1",
)

response = client.chat.completions.create(
    model="nvidia/NVIDIA-Nemotron-3.5-Super-VL",
    messages=[
        {"role": "user", "content": "Hello world!"}
    ],
    max_tokens=4096,
)

print(response.choices[0].message.content)

Node.js

import DevupAI from "devupai";

const client = new DevupAI({
  apiKey: process.env.DEVUP_API_KEY,
});

async function main() {
  const response = await client.chat.completions.create({
    model: "nvidia/NVIDIA-Nemotron-3.5-Super-VL",
    messages: [{ role: "user", content: "Hello world!" }],
    max_tokens: 4096,
  });

  console.log(response.choices[0].message.content);
}

main();

cURL

curl -X POST "https://api.devupai.com/v1/chat/completions" \
  -H "Authorization: Bearer $DEVUP_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "nvidia/NVIDIA-Nemotron-3.5-Super-VL",
    "messages": [
      { "role": "user", "content": "Hello world!" }
    ],
    "max_tokens": 4096
  }'

These examples reason. Reasoning is on by default, so even a greeting returns a trace — which is why the ceiling is 4,096 rather than 1,024.

Setting the Reasoning

REASONING = {
    "full":   {"chat_template_kwargs": {"enable_thinking": True}},
    "medium": {"chat_template_kwargs": {"enable_thinking": True, "medium_effort": True}},
    "off":    {"reasoning_effort": "none"},
}


def ask(prompt: str, *, reasoning: str = "medium", want: int = 16_384) -> str:
    """Send a text request at a chosen reasoning setting."""
    if reasoning not in REASONING:
        raise ValueError(f"unknown setting '{reasoning}' — use full, medium, or off")

    response = client.chat.completions.create(
        model="nvidia/NVIDIA-Nemotron-3.5-Super-VL",
        messages=[{"role": "user", "content": prompt}],
        temperature=1.0,
        top_p=0.95,
        max_tokens=want,
        extra_body=REASONING[reasoning],
    )

    choice = response.choices[0]

    if choice.finish_reason == "length":
        raise ValueError(
            f"truncated at {response.usage.completion_tokens:,} tokens — "
            f"raise max_tokens or lower the reasoning from '{reasoning}'"
        )

    return choice.message.content

off for one-answer work, medium for most work, full for the hard step.

Reading the reasoning and its cost

message = response.choices[0].message
usage = response.usage

trace = getattr(message, "reasoning_content", None)
details = getattr(usage, "completion_tokens_details", None)
reasoning_tokens = getattr(details, "reasoning_tokens", None)

print(f"reasoning: {reasoning_tokens} tokens of {usage.completion_tokens} completion tokens")
print(message.content)

The split is reported, so the cost of deliberation is visible per request rather than estimated.

Keep the trace out of anything a user reads. It is a working draft, not the answer.

Images and Documents

At the vision temperature.

import base64
from pathlib import Path

encoded = base64.b64encode(Path("invoice.png").read_bytes()).decode("utf-8")

response = client.chat.completions.create(
    model="nvidia/NVIDIA-Nemotron-3.5-Super-VL",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{encoded}"}},
                {
                    "type": "text",
                    "text": (
                        "Extract the supplier, invoice number, date, every line item with quantity "
                        "and amount, and the total. Copy text exactly as printed. Mark anything "
                        "illegible as unreadable rather than estimating it."
                    ),
                },
            ],
        }
    ],
    temperature=0.6,
    top_p=0.95,
    max_tokens=16_384,
    extra_body={"reasoning_effort": "none"},
)

print(response.choices[0].message.content)

Temperature 0.6, as recommended for vision. Extraction has one correct answer.

Reasoning off for straight extraction. Reading what is printed needs no deliberation; reconciling figures across pages is where medium or full reasoning earns its tokens.

Send pages at full resolution. Downscaling discards the detail that separates a 6 from an 8.

Structured Output

Schema-constrained output is supported — the response matches the JSON schema you supply.

import json

SCHEMA = {
    "name": "invoice",
    "strict": True,
    "schema": {
        "type": "object",
        "properties": {
            "supplier": {"type": "string"},
            "invoice_number": {"type": "string"},
            "total": {"type": "number"},
            "currency": {"type": "string"},
        },
        "required": ["supplier", "invoice_number", "total", "currency"],
        "additionalProperties": False,
    },
}

response = client.chat.completions.create(
    model="nvidia/NVIDIA-Nemotron-3.5-Super-VL",
    messages=[
        {"role": "user", "content": [
            {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{encoded}"}},
            {"type": "text", "text": "Extract the invoice fields."},
        ]},
    ],
    response_format={"type": "json_schema", "json_schema": SCHEMA},
    temperature=0.6,
    top_p=0.95,
    max_tokens=8192,
    extra_body={"reasoning_effort": "none"},
)

data = json.loads(response.choices[0].message.content)
print(data["supplier"], data["total"], data["currency"])

A schema turns extraction into a contract. Required keys, fixed types, and no extra fields — the output either matches or the request has told you something is wrong.

json_object is available too, when you need valid JSON without a fixed shape.

Validate anyway before writing to a system of record. A schema guarantees structure, not that the supplier name was read correctly.

Video

MP4 clips of up to two minutes.

import base64
from pathlib import Path

encoded = base64.b64encode(Path("demo.mp4").read_bytes()).decode("utf-8")

response = client.chat.completions.create(
    model="nvidia/NVIDIA-Nemotron-3.5-Super-VL",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "video_url", "video_url": {"url": f"data:video/mp4;base64,{encoded}"}},
                {"type": "text", "text": "Summarise the events in this video in order, with timestamps."},
            ],
        }
    ],
    temperature=0.6,
    top_p=0.95,
    max_tokens=16_384,
)

print(response.choices[0].message.content)

Keep clips under two minutes. That is the documented limit.

Every sampled frame becomes tokens. A two-minute clip consumes a meaningful share of the window before the question is even asked — and higher-resolution footage costs more per frame than lower.

Measure a typical clip first. Know what one of your videos costs in tokens before processing a library of them.

Tool Calling

All tool_choice modes are supported: auto, required, none, and a named function.

import json

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="nvidia/NVIDIA-Nemotron-3.5-Super-VL",
        messages=history,
        tools=TOOLS,
        tool_choice=tool_choice,
        temperature=1.0,
        top_p=0.95,
        max_tokens=16_384,
        extra_body={"chat_template_kwargs": {"enable_thinking": True, "medium_effort": True}},
    )
    choice = response.choices[0]
    if choice.finish_reason == "length":
        raise RuntimeError("response truncated — raise max_tokens")
    return choice.message


message = complete(messages)
messages.append(message.model_dump(exclude_none=True))

for call in message.tool_calls or []:
    arguments = json.loads(call.function.arguments)

    if (
        call.function.name != "get_inventory"
        or not isinstance(arguments, dict)
        or set(arguments) != {"product"}
        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)

Force a call with tool_choice="required" where a step must produce one — or name the function when your code already knows which tool is needed:

tool_choice={"type": "function", "function": {"name": "get_inventory"}}

Validate every argument before executing. The check above confirms the function name, the argument shape, and that the value is one the tool actually accepts — a forced call is not a correct one.

tool_choice="none" on the final turn makes the model answer from the tool result rather than calling again.

A Screen-Driven Agent Step

Where vision and action meet — the use OSWorld measures.

import base64
import json
from pathlib import Path

ACTIONS = [
    {
        "type": "function",
        "function": {
            "name": "click",
            "description": "Click the UI element with the given visible label.",
            "parameters": {
                "type": "object",
                "properties": {"label": {"type": "string"}},
                "required": ["label"],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "type_text",
            "description": "Type text into the currently focused field.",
            "parameters": {
                "type": "object",
                "properties": {"text": {"type": "string"}},
                "required": ["text"],
            },
        },
    },
]

screen = base64.b64encode(Path("screen.png").read_bytes()).decode("utf-8")

response = client.chat.completions.create(
    model="nvidia/NVIDIA-Nemotron-3.5-Super-VL",
    messages=[
        {
            "role": "system",
            "content": (
                "You operate a desktop application one action at a time. Name elements only by "
                "labels visible on the current screen. If the element you need is not visible, say "
                "so instead of guessing."
            ),
        },
        {
            "role": "user",
            "content": [
                {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{screen}"}},
                {"type": "text", "text": "Goal: export the current report as PDF. What is the next action?"},
            ],
        },
    ],
    tools=ACTIONS,
    tool_choice="required",
    temperature=0.6,
    top_p=0.95,
    max_tokens=8192,
    extra_body={"chat_template_kwargs": {"enable_thinking": True, "medium_effort": True}},
)

for call in response.choices[0].message.tool_calls or []:
    print(call.function.name, json.loads(call.function.arguments))

"Name elements only by labels visible on the current screen" is the instruction that keeps an interface agent honest. A model that invents a button it expects to exist produces an action that cannot be executed.

One action per step, then a fresh screenshot. The screen after a click is new information; acting on the old one is how agents drift.

Self-Hosting

Two official checkpoints: BF16 for customisation and full-precision evaluation, and NVFP4 for efficient deployment.

Reference hardware: four H100s or two GB200s for BF16.

Parsers: in vLLM, --reasoning-parser nemotron_v3 and --tool-call-parser qwen3_coder, with automatic tool choice enabled. In SGLang, --reasoning-parser nemotron_3 with the same tool-call parser.

Speculative decoding uses the model's own MTP head — no separate drafter is needed for the reference recipes. vLLM controls draft length through num_speculative_tokens; SGLang uses EAGLE with a top-k of one.

The reference video configuration samples up to 256 frames at 2 FPS with a pruning rate of 0.5; for 1080p footage, NVIDIA recommend 1 FPS and up to 128 frames.

Runtime support: vLLM and SGLang, on NVIDIA Blackwell and Hopper, under Linux.

Where It Fits

Document understanding — invoices, filings, contracts, and forms read as page images, at the vision temperature, into a schema you define.

Interface agents that read a screen and act on it.

Video understanding of short clips, up to two minutes each.

Coding agents shaped by training on pull requests, diffs, and CI logs.

Long-context retrieval, where its GraphWalks result is the strongest in its comparison.

Agents that must not bluff, given one of the lowest hallucination rates in its comparison.

Mixed workloads, with reasoning set per request — off, medium, or full — and its cost reported separately.

Less suited to the longest multi-hour agent evaluations, where its own published scores are weakest.

Not for audio. Text, images, and video in; text out.

Practical Notes

Reasoning is on by default — turn it off with reasoning_effort: "none" for extraction and classification.

Use chat_template_kwargs: {"medium_effort": true} for NVIDIA's medium reasoning mode.

Read reasoning tokens from the usage object to see what deliberation cost.

Use temperature 1.0 for text and 0.6 for vision — switch per request.

Size max_tokens for reasoning plus answer when reasoning is on, and check finish_reason.

Use json_schema for extraction you will write to a system of record — and still validate the values.

Design around 262,144 tokens, and count images and video frames against it.

Keep video clips under two minutes.

Send document pages and screenshots at full resolution.

Validate every tool argument before executing it.

Have interface agents name only elements visible on screen.

Read the OpenMDW-1.1 licence before commercial use.

Limitations

262,144-token window here, against an architectural maximum of one million.

Visual input consumes context. Every image and video frame becomes tokens inside the same window.

Video clips are limited to two minutes.

Reasoning is on by default. Every request deliberates unless told not to — the expensive setting for one-answer work.

Reasoning shares the output budget — a small max_tokens can end the response before the answer.

Weakest on the hardest long-horizon agent benchmarks — tau3-bench banking, AutomationBench, and Terminal Bench 4 — by NVIDIA's own figures.

MMLU-ProX is the lowest in its comparison. Broad multilingual knowledge is not its strongest axis.

Foundation training data ends December 2025.

Text output only. No audio input, no image or video generation.

Reasoning traces are working notes. Unpolished, sometimes exploring abandoned branches, and occasionally contradicting the answer that follows.