At a Glance

| | |
|---|---|
| Total parameters | 31B (Mamba2-Transformer hybrid MoE) |
| Active parameters | ~3B per token |
| Max context | 256k tokens |
| Modalities (in) | Video, Audio, Image, Text |
| Modality (out) | Text |
| Reasoning mode | On by default; toggle via enable_thinking |
| Best for | Video+speech analysis, document intelligence (OCR/charts/long docs), GUI/agentic workflows, ASR |
| Minimum GPU (BF16) | 1× H100 80GB (single-GPU); 1× B200 / 1× H200 recommended |
| Minimum GPU (FP8) | 1× L40S 48GB; 1× RTX Pro 6000 / 1× B200 recommended |
| Minimum GPU (NVFP4) | 1× RTX 5090 32GB; 1× DGX Spark / 1× Jetson Thor also supported |
| Precisions | BF16 (62 GB) · FP8 (33 GB) · NVFP4 (21 GB) |

Quick Start Guide

Model Parameters

Model Overview

Description:

This model is available for commercial use.

This model was improved using Qwen3-VL-30B-A3B-Instruct, Qwen3.5-122B-A10B, Qwen3.5-397B-A17B, Qwen2.5-VL-72B-Instruct, and gpt-oss-120b. For more information, please see the Training Dataset section below.

License/Terms of Use

Governing Terms: Use of this model is governed by the NVIDIA Open Model Agreement

Deployment Geography:

Use Case:

• Customer service applications (e.g., Doordash video of drop-off at a given address via OCR, drive-thru order verification)
• Media and Entertainment (M&E) — video and speech analysis, dense captions, video search and summarization
• Document intelligence for AI assistants (contracts, SOW/MSA, scientific discovery, financial documents)
• GUI automation for AI agentic applications (incident management, agentic search, browser agents, email agents)

Release Date:

• BF16
  
• FP8
  
• NVFP4
  

Model Architecture:

• Nemotron 3 Nano LLM (30B A3B) — 31B-parameter Mamba2-Transformer hybrid MoE backbone with ~3B active parameters per token.
• CRADIO v4-H — vision encoder for image and video frames.
• Parakeet — speech encoder for audio inputs.

Input(s):

• Video: mp4, up to 2 minutes. For 1080p videos, sample up to 1 FPS / 128 frames. For lower-resolution videos such as 720p, higher temporal sampling such as 2 FPS / 256 frames may be used.
• Audio: wav, mp3 files (up to 1 hour), 8kHz and higher sampling rates
• Image: Red, Green, Blue (RGB) (jpeg, png)
• Text: String
  

• Video: Three-Dimensional (3D)
• Audio: One-Dimensional (1D)
• Image: Two-Dimensional (2D)
• Text: One-Dimensional (1D)
  

• Maximum context length up to 256k tokens
• Language support: English only
  

Output(s)

• Text: String
  

• Text: One-Dimensional (1D)
  

• Maximum context length up to 256k tokens.
• Supports JSON output format
• Supports reasoning output with chain-of-thought
• Supports tool calling
• Supports word-level timestamps for transcription
  

Software Integration:

• vLLM
  
• NeMo
  
• Megatron
  
• NeMo-RL
  

• NVIDIA Ampere (A100 80GB SXM/NVLink)
  
• NVIDIA Blackwell (B200 SXM/NVLink, RTX Pro 6000 SE, DGX Spark, Jetson Thor, RTX 5090)
  
• NVIDIA Hopper (H100 SXM/NVLink, H200 SXM/NVLink)
  
• NVIDIA Lovelace (L40S)
  

• Linux
  

• vLLM
  
• TensorRT LLM
  
• TensorRT Edge-LLM
  
• llama.cpp
  
• Ollama
  
• SGLang
  

This AI model can be embedded as an Application Programming Interface (API) call into the software environment described above.

Model Version(s):

Download Model Weights

Install the HuggingFace CLI

pip install -U "huggingface_hub[hf_xet]"
 
Log in once; the token is cached at ~/.cache/huggingface/token
hf auth login
 
Sanity check: should print your username and orgs
hf auth whoami

vLLM

Required version: vLLM 0.20.0 is needed. This means one of these containers:

- CUDA 13.0: 'vllm/vllm-openai:v0.20.0'

• CUDA 12.9: 'vllm/vllm-openai:v0.20.0-cu129'

Container

docker pull vllm/vllm-openai:v0.20.0

Audio support: Within the vLLM container, before running vllm serve, if any audio will be used (including passing use_audio_in_video: true):

> python3 -m pip install "vllm[audio]"

General Invocation (1×GPU, e.g. 1×B200)

# vllm serve nvidia/Nemotron-3-Nano-Omni-30B-A3B-Reasoning-BF16 \
vllm serve nvidia/Nemotron-3-Nano-Omni-30B-A3B-Reasoning-FP8 \
vllm serve nvidia/Nemotron-3-Nano-Omni-30B-A3B-Reasoning-NVFP4 \
  --host 0.0.0.0 \
  --max-model-len 131072 \
  --tensor-parallel-size 1 \
  --trust-remote-code \
  --video-pruning-rate 0.5 \
  --max-num-seqs 384 \
  --allowed-local-media-path / \
  --media-io-kwargs '{"video": {"fps": 2, "num_frames": 256}}' \
  --reasoning-parser nemotron_v3 \
  --enable-auto-tool-choice \
  --tool-call-parser qwen3_coder \
  --kv-cache-dtype fp8 # Omit this for BF16

Platform-Specific Notes

RTX Pro: Due to a current bug with FlashInfer + RTX Pro, append: --moe-backend triton

##### vLLM on DGX Spark (aarch64 / ARM64)

For everything not covered here (API examples, reasoning mode, video tuning), follow the general instructions.

###### 1. Pull the container image

Use the upstream multi-arch vLLM v0.20.0 docker image. Docker will automatically pull the arm64 variant.

docker pull vllm/vllm-openai:v0.20.0

###### 2. Launch the vLLM server on Spark

WEIGHTS=/path/to/nemotron-3-nano-omni-weights
The image does not include audio packages so we need to install them with "pip install vllm[audio]" as done in the command below
docker run --rm -it \
  --gpus all \
  --ipc=host -p 8000:8000 \
  --shm-size=16g \
  --name vllm-nemotron-omni \
  -v "${WEIGHTS}:/model:ro" \
  --entrypoint /bin/bash \
  vllm/vllm-openai:v0.20.0 -c  \
  "pip install vllm[audio] && vllm serve /model \
  --served-model-name=nemotron_3_nano_omni \
  --max-num-seqs 8 \
  --max-model-len 131072 \
  --port 8000 \
  --trust-remote-code \
  --gpu-memory-utilization 0.8 \
  --limit-mm-per-prompt '{\"video\": 1, \"image\": 1, \"audio\": 1}' \
  --media-io-kwargs '{\"video\": {\"fps\": 2,  \"num_frames\": 256}}' \
  --allowed-local-media-path=/ \
  --enable-prefix-caching \
  --max-num-batched-tokens 32768 \
  --reasoning-parser nemotron_v3 \
  --enable-auto-tool-choice \
  --tool-call-parser qwen3_coder"

In another terminal, verify the server is ready:

curl -sS http://localhost:8000/v1/models | python3 -m json.tool

###### Key Spark-Specific Flags

| Flag | Purpose | Spark Guidance |
|------|---------|----------------|
| --gpus all | Select GPU | Spark has one GB10 GPU; all is equivalent to device=0 |
| --max-model-len | Max context window | Start at 131072; reduce if you hit OOM (see Memory Tuning below) |

###### Memory Tuning on Spark

Spark uses unified LPDDR5X memory (~128 GB shared between CPU and GPU), not separate system + VRAM pools. Two levers, in order of impact:

  --gpu-memory-utilization=0.70 \
  --max-model-len=32768 \

TensorRT-LLM

This model can also be deployed with TensorRT-LLM - see relevant instructions here.

Platform-Specific Notes

##### TensorRT Edge-LLM

This model can also be deployed with TensorRT Edge-LLM on NVIDIA Jetson Thor - see the Jetson AI Lab model page and the TensorRT Edge-LLM Quick Start Guide.

SGLang

The BF16 variant of this model is supported on SGLang, with the following images:

• CUDA 13.0: lmsysorg/sglang:dev-cu13-nemotronh-nano-omni-reasoning-v3
• CUDA 12.9: lmsysorg/sglang:dev-nemotronh-nano-omni-reasoning-v3

To serve:
sglang serve --model-path nvidia/Nemotron-3-Nano-Omni-30B-A3B-Reasoning-BF16 --trust-remote-code

NOTE: NVFP4 and FP8 support to come.

Platform-Specific Notes

##### SGLang on DGX Spark (aarch64 / ARM64)

For everything not covered here (API examples, reasoning mode, video tuning), follow the general instructions.

###### 1. Pull the container image

Use the upstream multi-arch CUDA 13.0 docker image linked above. Docker will automatically pull the arm64 variant.

docker pull lmsysorg/sglang:dev-cu13-nemotronh-nano-omni-reasoning-v3

###### 2. Launch the SGLang server on Spark

WEIGHTS=/path/to/nemotron-3-nano-omni-weights
The image does not include audio packages so we need to install them with "pip install librosa" as done in the command below
docker run --gpus all -it --rm \
  -p 30000:30000 \
  -v "${WEIGHTS}:/model:ro" \
  --shm-size 16g \
  lmsysorg/sglang:dev-cu13-nemotronh-nano-omni-reasoning-v3 \
  bash -c "pip install librosa && python3 -m sglang.launch_server --model-path /model \
  --host 0.0.0.0 \
  --port 30000 \
  --trust-remote-code \
  --mem-fraction-static 0.8 \
  --max-running-requests 8 \
  --tool-call-parser qwen3_coder \
  --reasoning-parser nemotron_3"

In another terminal, verify the server is ready:

curl -sS http://localhost:30000/v1/models | python3 -m json.tool

###### Key Spark-Specific Flags

| Flag | Purpose | Spark Guidance |
|------|---------|----------------|
| --gpus all | Select GPU | Spark has one GB10 GPU; all is equivalent to device=0 |
| --context-length | Max context window | Start with default; reduce if you hit OOM (see Memory Tuning below) |

###### Memory Tuning on Spark

Spark uses unified LPDDR5X memory (~128 GB shared between CPU and GPU), not separate system + VRAM pools. Two levers, in order of impact:

  --mem-fraction-static=0.70 \
  --context-length=32768 \

API Client (OpenAI-compatible)

from openai import OpenAI
client = OpenAI(base_url="http://localhost:8000/v1", api_key="")
MODEL = "nvidia/Nemotron-3-Nano-Omni-30B-A3B-Reasoning-NVFP4"

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}"
 
image_url = image_to_data_url("media/example1a.jpeg")
 
response = client.chat.completions.create(
    model=MODEL,
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Describe this image in detail."},
                {"type": "image_url", "image_url": {"url": image_url}},
            ],
        }
    ],
    max_tokens=1024,
    temperature=0.2,
    extra_body={"top_k": 1, "chat_template_kwargs": {"enable_thinking": False}},
)
print(response.choices[0].message.content)

from pathlib import Path
 
audio_url = Path("media/2414-165385-0000.wav").resolve().as_uri()
 
response = client.chat.completions.create(
    model=MODEL,
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "audio_url", "audio_url": {"url": audio_url}},
                {"type": "text", "text": "Transcribe this audio."},
            ],
        }
    ],
    max_tokens=1024,
    temperature=0.2,
    extra_body={"top_k": 1, "chat_template_kwargs": {"enable_thinking": False}},
)
print(response.choices[0].message.content)

from pathlib import Path
 
video_url = Path("media/demo.mp4").resolve().as_uri()
reasoning_budget = 16384
grace_period = 1024
 
response = client.chat.completions.create(
    model=MODEL,
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "video_url", "video_url": {"url": video_url}},
                {"type": "text", "text": "Describe this video."},
            ],
        }
    ],
    max_tokens=20480,
    temperature=0.6,
    top_p=0.95,
    extra_body={
        "thinking_token_budget": reasoning_budget + grace_period,
        "chat_template_kwargs": {
            "enable_thinking": True,
            "reasoning_budget": reasoning_budget,
        },
        "mm_processor_kwargs": {"use_audio_in_video": False},
    },
)
print(response.choices[0].message.content)

curl -sS http://localhost:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{"model":"nvidia/Nemotron-3-Nano-Omni-30B-A3B-Reasoning-NVFP4","messages":[{"role":"user","content":"Hello, what can you do?"}],"temperature":0.2,"top_k":1}' \
  | python3 -c "import sys,json; print(json.load(sys.stdin)['choices'][0]['message']['content'])"

#!/usr/bin/env python3
"""Send PDF page(s) as images to a vLLM /v1/chat/completions endpoint."""
from __future__ import annotations
 
import argparse, base64, sys
from io import BytesIO
from pathlib import Path
 
import requests
 
try:
    import fitz
    from PIL import Image
except ImportError:
    print("Install: pip install pymupdf pillow requests", file=sys.stderr)
    sys.exit(1)
 
USER_PROMPT = (
    "Summarize this PDF page: main topic, section headings, important facts "
    "or bullets, and a brief note on each figure or table. "
    "Do not invent text you cannot read."
)
API_URL = "http://localhost:8000/v1/chat/completions"
MODEL = "nvidia/Nemotron-3-Nano-Omni-30B-A3B-Reasoning-NVFP4"
MAX_TOKENS = 32000
DPI = 150
 
 
def page_to_b64(pdf_path: str, idx: int) -> str:
    doc = fitz.open(pdf_path)
    z = DPI / 72.0
    pix = doc.load_page(idx).get_pixmap(matrix=fitz.Matrix(z, z))
    img = Image.frombytes("RGB", [pix.width, pix.height], pix.samples)
    doc.close()
    buf = BytesIO()
    img.save(buf, format="PNG")
    return base64.b64encode(buf.getvalue()).decode("ascii")
 
 
def chat(url, model, b64, text, max_tokens):
    r = requests.post(url, json={
        "model": model,
        "messages": [{"role": "user", "content": [
            {"type": "text", "text": text},
            {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{b64}"}},
        ]}],
        "max_tokens": max_tokens,
        "stream": False,
        "temperature": 0.2,
        "chat_template_kwargs": {"enable_thinking": False},
    }, timeout=120)
    r.raise_for_status()
    return r.json()["choices"][0]["message"]["content"]
 
 
def main():
    p = argparse.ArgumentParser()
    p.add_argument("pdf")
    p.add_argument("--page", type=int, default=0)
    p.add_argument("--all-pages", action="store_true")
    p.add_argument("-o", "--output")
    p.add_argument("--url", default=API_URL)
    p.add_argument("--model", default=MODEL)
    p.add_argument("--max-tokens", type=int, default=MAX_TOKENS)
    a = p.parse_args()
 
    doc = fitz.open(a.pdf); n = len(doc); doc.close()
    pages = range(n) if a.all_pages else [a.page]
    parts = [f"# Extracted: {Path(a.pdf).name}\n\nPages: {n}\n"] if a.all_pages else []
 
    for i in pages:
        print(f"Page {i+1}/{n} ...", file=sys.stderr)
        b64 = page_to_b64(a.pdf, i)
        text = chat(a.url, a.model, b64, f"Page {i+1}.\n\n{USER_PROMPT}", a.max_tokens)
        parts.append(f"\n---\n\n## Page {i+1}\n\n{text.strip()}\n" if a.all_pages else text.strip())
 
    out = "\n".join(parts)
    if a.output:
        Path(a.output).write_text(out + "\n", encoding="utf-8")
    else:
        print(out)
 
if __name__ == "__main__":
    main()

python3 pdf_vlm_chat.py /path/to/your_document.pdf --page 0

python3 pdf_vlm_chat.py /path/to/your_document.pdf --all-pages -o extracted.md

Edit USER_PROMPT in the script for different tasks (detailed extraction, table parsing, etc.).

Reasoning Mode (enable_thinking)

"chat_template_kwargs": {"enable_thinking": false}

In the Python heredoc pattern, use False (Python boolean), not false (invalid Python).

We recommend thinking mode for tasks that involve reasoning and complex understanding. For video, audio, and omni use cases, try both enabling and disabling thinking for best results.

from typing import Any, Dict, List
from openai import OpenAI
from transformers import AutoTokenizer
class ThinkingBudgetClient:
    def __init__(self, base_url: str, api_key: str, tokenizer_name_or_path: str):
        self.tokenizer = AutoTokenizer.from_pretrained(
            tokenizer_name_or_path, trust_remote_code=True
        )
        self.client = OpenAI(base_url=base_url, api_key=api_key)
def chat_completion(
        self,
        model: str,
        messages: List[Dict[str, Any]],
        reasoning_budget: int = 512,
        max_tokens: int = 1024,
        **kwargs,
    ) -> Dict[str, Any]:
        assert max_tokens > reasoning_budget, (
            f"reasoning_budget must be less than max_tokens. "
            f"Got {max_tokens=} and {reasoning_budget=}"
        )
# Step 1: generate only the reasoning trace up to the requested budget.
        response = self.client.chat.completions.create(
            model=model,
            messages=messages,
            max_tokens=reasoning_budget,
            extra_body={
                "top_k": 1,
                "chat_template_kwargs": {
                    "enable_thinking": True,
                },
            },
            **kwargs,
        )
        reasoning_content = response.choices[0].message.content or ""
        if "</think>" not in reasoning_content:
            print("No </think> found in reasoning content")
            reasoning_content = f"{reasoning_content}</think>\n\n"
reasoning_tokens_len = len(
            self.tokenizer.encode(reasoning_content, add_special_tokens=False)
        )
        remaining_tokens = max_tokens - reasoning_tokens_len
        assert remaining_tokens > 0, (
            f"No tokens remaining for response ({remaining_tokens=}). "
            "Increase max_tokens or lower reasoning_budget."
        )
# Step 2: continue from the closed reasoning trace and ask for the final answer.
        continued_messages = messages + [
            {"role": "assistant", "content": reasoning_content}
        ]
        prompt = self.tokenizer.apply_chat_template(
            continued_messages,
            tokenize=False,
            continue_final_message=True,
        )
        response = self.client.completions.create(
            model=model,
            prompt=prompt,
            max_tokens=remaining_tokens,
            extra_body={"top_k": 1},
            **kwargs,
        )
return {
            "reasoning_content": reasoning_content.strip(),
            "content": response.choices[0].text,
            "finish_reason": response.choices[0].finish_reason,
        }

Video Tuning

Frame sampling (--media-io-kwargs)

Without explicit settings, vLLM may default to ~32 frames per video regardless of length. Always set --media-io-kwargs at server launch (already included in the General Invocation above):

--media-io-kwargs '{"video": {"fps": 2, "num_frames": 256}}'

Recommended num_frames ranges (at fps=2):

| GPU memory | Recommended num_frames range |
|------------|--------------------------------|
| 80 GB (A100/H100) | 128–512 |
| ≤40 GB | 64–256 |

Higher values improve temporal coverage but increase VRAM and prefill time. Start at the low end of the range and increase as your workload and latency budget allow.

Notes

Jetson Deployment

For Jetson deployments, vLLM, SGLang, Ollama, llama.cpp, and TensorRT Edge-LLM are supported inference frameworks; see the Jetson AI Lab model page for more details.

TensorRT Edge-LLM support is only for Jetson Thor; TensorRT-LLM is not supported on Jetson.

Training, Testing, and Evaluation Datasets:

Dataset Overview

Dataset Description

| Modality | Dataset Entries | Samples | Est. Tokens (M) |
|---|---|---|---|
| text+audio | 220 | 259,178,821 | 143,533.1 |
| text+image | 750 | 70,143,901 | 180,347.1 |
| text+video | 241 | 15,837,673 | 239,631.5 |
| text+video+audio | 155 | 8,720,044 | 152,499.2 |
| text | 12 | 707,187 | 958.4 |
| Total | 1395 | 354,587,705 | 716,969.2 |

Training data for Nemotron-Omni was assembled from a diverse collection of audio, image, video, and text datasets. Raw datasets were first converted into a standardized JSONL format with unified conversation-turn structure. Audio data was resampled to 16 kHz where needed. Image and video datasets were paired with question-answer annotations, often regenerated or refined using large vision-language models to improve quality and consistency. Quality filtering was applied using model-based judges to remove low-quality, unsafe, or off-topic samples. Deduplication and CSAM scanning were performed across all image datasets. Data was then packed into fixed-length sequences (32k, 128k, or 256k tokens) for efficient training.

Multiple safety measures were implemented throughout the data pipeline. All image/text datasets underwent CSAM (Child Sexual Abuse Material) scanning, with results tracked per dataset. Content safety filtering was applied using two independent safety judge models to flag and remove samples containing harmful content including weapons references, criminal planning, sexual content involving minors, harassment, hate speech, profanity, threats, violence, or suicide-related content. Synthetic data generation pipelines included explicit quality and safety filtering stages. Identity-fix processing was applied to correct potential biases in generated responses. The multi-stage pipeline (original → cleaned → clean+safe → clean+safe+holdout) ensured progressive refinement, with each stage removing additional problematic content.

We built on the base model, applying additional training, enhancements, and optimizations on top of it.

Public Datasets

Private Datasets

Self-Sourced Synthetic Data

• Overall Size: 41,502,625 samples across modalities: text+audio, text+image, text+video
  

• Description of synthetic data generation methods:
  

NVIDIA-Sourced Synthetic Datasets

Training Dataset:

• Audio
  
• Image
  
• Text
  
• Video
  

• 10,000 to 1 Million Hours
  

• 1 Million to 1 Billion Images
  

• 1 Billion to 10 Trillion Tokens
  

• 10,000 to 1 Million Hours
  

• Hybrid: Human, Automated, Synthetic
  

• Hybrid: Human, Automated, Synthetic
  

Evaluation Dataset:

| Task | Multimodal Benchmarks | Nemotron 3 Nano Omni | Nemotron Nano VL V2 | % Improvement |
|---|---|---|---|---|
| Grounding | CVBench2D | 83.95 | 78.3 | 6.73 |
| Document | OCRBenchV2 (EN) | 67.04 | 54.8 | 18.26 |
| Computer Use | OSWorld | 47.4 | 11.1 | 76.58 |
| Chart Reasoning | Charxiv Reasoning | 63.6 | 41.3 | 35.06 |
| Multi-Image Reasoning | MMlongBench Doc | 57.5 | 38 | 33.91 |
| Math Reasoning | MathVista_MINI | 82.8 | 75.5 | 8.82 |
| OCR Reasoning | OCR_Reasoning | 54.14 | 33.9 | 33.87 |
| Video Q/A | Video MME | 72.2 | - | - |
| Video + Audio Q/A | World Sense | 55.4 | - | - |
| Video + Audio Q/A | Daily Omni | 74.52 | - | - |
| Speech Instruction Following | Voice interaction | 89.39 | - | - |

We release FP8 and NVFP4 quantized variants alongside the BF16 model. The FP8 variant quantizes every linear layer in the language model to per-tensor E4M3 (with the exception of the MoE router and lm_head) and pairs it with an FP8 KV cache, yielding 8.5 effective bits per weight (32.8 GB). The NVFP4 variant uses a mixed-precision recipe inspired by Nemotron 3 Super: routed MoE experts are quantized to NVFP4 (FP4 E2M1 values with per-block FP8 E4M3 scales over groups of 16 elements and an additional per-tensor FP32 global scale), while the Mamba in_proj / out_proj, shared experts, and attention o_proj are quantized to FP8, yielding 4.98 effective bits per weight (20.9 GB). In both variants the vision and audio encoders and their MLP projectors are kept in BF16.

The table below reports FP8 & NVFP4 accuracy against a BF16 baseline using non-reasoning mode. Across 9 multimodal benchmarks, both quantized variants stay within 1 point of BF16 on average.

| Footprint | BF16 | FP8 | NVFP4 |
|---|---|---|---|
| Size (GB) | 61.5 | 32.8 | 20.9 |
| Effective bpw | 16.00 | 8.5 | 4.98 |

| Benchmark | BF16 | FP8 | NVFP4 |
|---|---|---|---|
| MathVista_MINI | 71.90 | 71.05 | 71.30 |
| Charxiv Reasoning | 49.10 | 48.05 | 47.95 |
| MMlongBench Doc | 46.10 | 45.84 | 45.78 |
| OCRBenchV2 (EN) | 65.80 | 65.63 | 65.77 |
| CVBench2D | 84.20 | 85.62 | 85.27 |
| Video MME | 70.80 | 69.40 | 69.60 |
| Daily Omni | 74.50 | 74.06 | 74.23 |
| World Sense | 55.20 | 54.40 | 54.60 |
| MMAU | 74.62 | 74.56 | 74.34 |
| Tedium Long (WER↓) | 3.11 | 3.12 | 3.04 |
| HF-ASR (WER↓) | 5.95 | 5.97 | 5.95 |
| Mean (9 non-ASR) | 65.80 | 65.40 | 65.43 |
| Median (9 non-ASR) | 70.80 | 69.40 | 69.60 |
| Δ vs BF16 (mean) | --- | −0.40 | −0.38 |

Data Collection Method by dataset:

• Hybrid: Human, Automated — Evaluation benchmarks are primarily human-curated public academic datasets with automated scoring.
  

• Human
  

Prior to training this model, NVIDIA implemented measures to respect EU text and data mining opt-outs by (1) respecting robots.txt instructions to the extent such signals reflect valid rights reservations, and (2) filtering datasets on any actionable metadata identifiers provided by rightsholders.

Inference:

• NVIDIA H100 SXM
  
• NVIDIA H200 SXM
  
• NVIDIA B200 SXM
  
• NVIDIA A100 80GB SXM
  
• NVIDIA GB200 NVL72
  
• NVIDIA RTX PRO 6000 SE Blackwell
  
• NVIDIA L40S PCIe 48GB
  
• NVIDIA DGX Spark
  
• NVIDIA Jetson Thor
  
• NVIDIA RTX 5090

Best Practices

We recommend following settings for reaching the optimal performance.

Sampling Parameters

• Thinking mode for long document analysis and multimodal reasoning tasks:
  

• Instruct mode (non-thinking) for general tasks:
  

• For ASR tasks, we recommend non-thinking mode with
  

Model output length

Ethical Considerations:

Please make sure you have proper rights and permissions for all input image and video content; if image or video includes people, personal health information, or intellectual property, the image or video generated will not blur or maintain proportions of image subjects included.

For more detailed information on ethical considerations for this model, please see the Model Card++ Bias, Explainability, Safety & Security, and Privacy Subcards.

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

Citation:

@misc{nvidia2026nemotron3nanoomni,
      title={Nemotron 3 Nano Omni: Efficient and Open Multimodal Intelligence}, 
      author={NVIDIA},
      year={2026},
      eprint={2604.24954},
      archivePrefix={arXiv},
      primaryClass={cs.LG},
      url={https://arxiv.org/abs/2604.24954}, 
}