NVIDIA Nemotron 3 Nano Omni: Multimodal Agent Dev Guide

When most teams build a multimodal AI agent, they stitch together separate models: a vision model for screenshots, a speech-to-text model for audio, a document parser for PDFs, and a language model to reason across all of it. The pipeline is expensive to maintain, the context handoffs lose information, and each model adds latency.

NVIDIA's Nemotron 3 Nano Omni, released April 28, 2026, is designed to collapse that stack into a single open model. It processes text, images, video, audio, and documents natively — not through a pipeline of specialized sub-models, but through a unified architecture where all modalities share the same reasoning path. And it does this while activating only 3 billion of its 30 billion parameters per inference token, making it deployable on a single GPU with 25GB of VRAM.

This guide covers the architecture, verified benchmark numbers, deployment options, and where Nemotron 3 Nano Omni fits (and doesn't fit) in a real agentic system.

Why the Architecture Decision Matters

The model's core technical bet is a hybrid Mamba-Transformer Mixture-of-Experts (MoE) backbone. Understanding each piece helps explain why NVIDIA made this design choice.

MoE: 30B parameters, 3B active

Standard dense models activate every parameter for every token. A 30B dense model costs the compute of 30B parameters on each forward pass. Nemotron 3 Nano Omni uses sparse MoE: 128 experts per MoE layer, routing each token to the top 6 experts plus a shared expert. For any given token, only a fraction of the model's weights are active.

This is why the model runs on 25GB of RAM (FP8 quantized) rather than the 60+ GB a comparable dense model would require.

Mamba SSM: efficient long-context processing

The backbone mixes three layer types:

• 23 Mamba selective state-space model (SSM) layers
• 23 MoE layers with 128 experts, top-6 routing, and a shared expert
• 6 grouped-query attention (GQA) layers

The Mamba layers handle the 256K context window efficiently. Traditional attention scales quadratically with context length — processing a 256K-token document with a pure-attention model is computationally expensive. Mamba's recurrent-style processing keeps long-context costs manageable.

The 6 GQA layers are placed strategically to preserve global context where it matters most. This hybrid means the model gets Mamba's context efficiency without losing the global expressivity that attention provides for complex reasoning.

Modality encoders

Attached to the language backbone:

• Vision: C-RADIOv4-H — handles dynamic resolution for images, charts, screenshots, and documents
• Audio: Parakeet-TDT-0.6B-v2 — processes speech and general audio
• Video: Conv3D temporal compression samples video frames efficiently before they enter the context window

All three encoders feed into the same reasoning backbone, so the model can tie what was said in an audio clip to what appeared on screen at the same timestamp — in a single reasoning stream.

What the Model Can Process

Nemotron 3 Nano Omni accepts any combination of these inputs in a single prompt:

• Text: standard language model input
• Images: photos, charts, diagrams, screenshots, document pages
• Video: MP4 and similar formats; Conv3D temporal compression handles long clips
• Audio: speech recognition, audio content analysis
• Documents: PDFs, financial statements, contracts — the vision encoder handles document layout and text extraction together

The 256K context window means a single prompt can include multiple long documents, an audio transcript, and several video frame sequences simultaneously.

Verified Benchmark Numbers

These figures come from NVIDIA's official sources and the MediaPerf benchmark run by Coactive.

MediaPerf (video understanding benchmark)

MediaPerf measures throughput in hours-of-video processed per hour of compute time, and cost per run.

On the tagging task (classifying video content at scale):

• Nemotron 3 Nano Omni: 9.91 hours of video per compute hour
• GPT-5.1: approximately 5× slower
• Gemini 3.0 Pro: approximately 6× slower
• Qwen3-VL: approximately 2.6× slower
• Cost: $14.27 per run (lowest across all benchmarked models)

On the summarization task:

• Nemotron 3 Nano Omni: 10.79 hours of video per compute hour
• GPT-5.1: approximately 4× slower
• Gemini 3.0 Pro: approximately 4× slower
• Qwen3-VL: approximately 2.7× slower

Document efficiency

Compared to other open omni models with equivalent interactivity, the model delivers 7.4× higher system efficiency on multi-document workloads and 9.2× higher on video workloads.

Single-stream reasoning

2.9× the single-stream reasoning speed compared to alternatives in multimodal scenarios.

These are NVIDIA-reported benchmarks on specific workloads. Real-world performance on your specific data will vary. The throughput advantage is structural (MoE sparse activation) and reproducible — but document layout quality, audio clarity, and video content complexity all affect practical outcomes.

Strengths
<ul>
  <li>Free via OpenRouter — zero cost to start experimenting</li>
  <li>Open weights: BF16, FP8, and NVFP4 on Hugging Face</li>
  <li>Single architecture handles text, image, audio, video, documents</li>
  <li>25GB VRAM for FP8 — fits a single A100 or H100 40GB</li>
  <li>256K context window with Mamba efficiency</li>
  <li>OpenAI-compatible API via vLLM — drop-in for existing integrations</li>
</ul>


Limitations
<ul>
  <li>NVFP4 quantization requires Blackwell GPU (Ada+)</li>
  <li>BF16 full precision requires ~60GB disk and 48GB+ VRAM</li>
  <li>Free OpenRouter tier rate-limited to ~20 req/min, 200 req/day</li>
  <li>MoE inference at scale requires careful batching for efficiency</li>
  <li>Audio and video processing adds latency vs text-only queries</li>
</ul>

Deployment Options

1. OpenRouter (free, zero setup)

The fastest path to trying Nemotron 3 Nano Omni is the free OpenRouter endpoint. At time of writing, it costs $0 per million input and output tokens, though rate limits apply (approximately 20 requests per minute, 200 per day on the free tier).

Model ID: nvidia/nemotron-3-nano-omni-30b-a3b-reasoning:free

import openai

client = openai.OpenAI(
    base_url="https://openrouter.ai/api/v1",
    api_key="your_openrouter_key",
)

response = client.chat.completions.create(
    model="nvidia/nemotron-3-nano-omni-30b-a3b-reasoning:free",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Describe what is happening in this video."},
                {"type": "image_url", "image_url": {"url": "data:image/jpeg;base64,..."}},
            ],
        }
    ],
)
print(response.choices[0].message.content)

The OpenAI-compatible API means any existing code using the OpenAI SDK works here with a URL swap.

2. NVIDIA NIM microservice (build.nvidia.com)

NVIDIA NIM provides an optimized containerized deployment with hardware-aware inference. This is the recommended path for production workloads where you want NVIDIA-supported reliability and TensorRT-LLM optimizations.

Access through build.nvidia.com. The NIM abstracts away quantization and batching configuration; you call the same OpenAI-compatible API but the backend is TensorRT-LLM running on NVIDIA-optimized infrastructure.

3. Self-hosted with vLLM

If you need data residency or want to run on your own GPU infrastructure, vLLM is the community-supported path. The official vLLM blog post (published the same day as the model release) covers the full setup.

Prerequisites:

• Single A100 40GB or H100 40GB for FP8 variant (~25GB active VRAM)
• H100 80GB or 2× A100 80GB for BF16
• vLLM installed with pip install vllm

Serve the model:

python3 -m vllm.entrypoints.openai.api_server \
  --model "nvidia/Nemotron-3-Nano-Omni-30B-A3B-Reasoning-BF16" \
  --served-model-name nemotron \
  --trust-remote-code \
  --dtype auto \
  --host 0.0.0.0 \
  --port 5000 \
  --tensor-parallel-size 1 \
  --max-model-len 131072

Use --dtype fp8 if your GPU supports FP8 to halve memory usage. For multi-GPU setups, increase --tensor-parallel-size.

After serving, the endpoint is OpenAI-compatible at http://localhost:5000/v1.

NVIDIA provides a vLLM cookbook in the NVIDIA-NeMo/Nemotron GitHub repository at usage-cookbook/Nemotron-3-Nano-Omni/vllm_cookbook.ipynb, which covers multimodal input formatting and batching strategies.

4. Amazon SageMaker JumpStart

AWS added Nemotron 3 Nano Omni to SageMaker JumpStart on April 29, 2026, one day after release. This gives you a managed deployment with SageMaker's scaling, logging, and IAM integration — useful if your infrastructure is already in AWS.

5. LM Studio (local desktop)

For local experimentation without GPU optimization overhead, LM Studio supports the model. Search for "nemotron-3-omni" in the LM Studio model browser. This path is slower than vLLM but requires no server setup.

Where This Fits in an Agentic Pipeline

Nemotron 3 Nano Omni is positioned as a perception sub-agent: a model that handles all multimodal input processing and feeds structured understanding into an orchestration layer.

Agentic computer use

The model is trained for computer use scenarios — it can interpret a GUI screenshot, track UI state across a sequence of frames, and reason about what action to take next. Practical applications include browser automation agents that need to understand what's currently displayed, incident response agents monitoring dashboards, and customer support workflows that analyze screen recordings.

Document intelligence at scale

For pipelines processing contracts, financial statements, or research papers, Nemotron 3 Nano Omni's document understanding handles layout-aware extraction — it sees the table structure and the text within it rather than treating the page as a flat stream of characters. The 256K context means an entire lengthy contract or multi-page report can fit in a single call.

Audio and video monitoring

Customer support call analysis, meeting transcription with visual context, video content tagging at scale — these are the workloads where the MediaPerf numbers translate to real cost differences. At 9.91 hours of video processed per compute hour on tagging tasks, running continuous video monitoring becomes cost-viable in a way that GPT-5.1 or Gemini 3.0 Pro equivalent workloads are not.

Architecture pattern: perception + reasoning

The model itself describes its intended role: feed the perceptual output into a separate reasoning or orchestration agent. A common pattern is using Nemotron 3 Nano Omni to extract structured observations from multimodal inputs, then passing those observations to a reasoning model (or using Nemotron 3 Nano Omni's own reasoning capabilities for the next step).

Common Mistakes to Avoid

Treating it as a replacement for specialized models in all cases

Nemotron 3 Nano Omni is faster and cheaper than combining multiple specialized models for mixed-modality workloads. For pure-text tasks or specialized high-accuracy document OCR where you've tuned a specialized model, a dedicated model may still outperform it.

Using BF16 without checking VRAM

The BF16 checkpoint requires roughly 60GB of disk space and 48GB+ VRAM. Most teams will want FP8 (25GB VRAM) or NVFP4 (requires Blackwell GPU). Check huggingface-cli download disk space requirements before pulling.

Ignoring the Mamba-specific attention pattern

The hybrid Mamba-Transformer architecture means some attention patterns differ from pure-transformer models. If you're migrating a prompt that relies on very specific cross-document attention behavior (e.g., fine-grained citation linking across documents), test against your specific data — don't assume the same behavior as a pure-transformer model.

Setting max-model-len too high in vLLM without enough VRAM

The 256K context window is the theoretical maximum. In practice, a 256K-token context with multimodal content requires substantially more VRAM than text-only. Start with --max-model-len 131072 (128K) and increase based on your actual workload requirements and available memory.

FAQ

Q: Is Nemotron 3 Nano Omni truly open-source?

The model weights are publicly available on Hugging Face under NVIDIA's open model license — not Apache 2.0. You can inspect the license at the HuggingFace model card before using it commercially. The training recipes and usage cookbooks in NVIDIA-NeMo/Nemotron are MIT-licensed.

Q: How does the 9x throughput claim compare to what I'll see in practice?

The 9x figure comes from MediaPerf, a video understanding benchmark focused on tagging and summarization at scale. This reflects the MoE architecture's structural advantage on batch workloads. Single-request interactive use shows a smaller advantage (~2.9x single-stream). For production video processing pipelines, the batch throughput improvement is real — for low-volume interactive applications, the gap narrows.

Q: Can I fine-tune Nemotron 3 Nano Omni?

NVIDIA provides training recipes in the NVIDIA-NeMo/Nemotron GitHub repository. The NVFP4 checkpoint is designed for Blackwell GPU fine-tuning. Fine-tuning the full BF16 model requires multi-GPU setup. The Hugging Face GGUF community variant (from Unsloth) is better suited for LoRA fine-tuning on consumer hardware.

Q: What's the difference between the Omni and the base Nemotron 3 Nano?

The base Nemotron 3 Nano (also on Hugging Face at nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B-BF16) is text-only — no vision or audio encoders. It uses the same MoE language backbone. Nemotron 3 Nano Omni adds the C-RADIOv4-H vision encoder and Parakeet-TDT audio encoder to the base for full multimodal support.

Q: Is it available on Google Cloud or Azure?

As of the April 28, 2026 release, confirmed deployments are on AWS SageMaker JumpStart, NVIDIA build.nvidia.com (NIM), and fal.ai. Google Cloud and Azure availability is not confirmed from available sources at time of writing — check NVIDIA's NIM ecosystem page for updates.

Key Takeaways

Nemotron 3 Nano Omni is a well-engineered model for specific workloads: mixed-modality pipelines where you are currently running separate models for vision, audio, and language, or video and document processing at scale where throughput cost matters.

The open weights, free OpenRouter tier, and OpenAI-compatible API lower the barrier to evaluation significantly. Effloow Lab verified the Hugging Face model cards, OpenRouter availability, and vLLM serve command from official sources — the model is accessible and deployment-ready as documented.

Where it fits best: agentic pipelines with diverse input types, video tagging and summarization at volume, document-heavy enterprise workflows. Where to test carefully first: tasks where you've already optimized a specialized model, pure-text workloads that don't need multimodal capabilities, or environments without GPU access (the free OpenRouter tier has meaningful rate limits for production use).

The technical report (arXiv:2604.24954) is publicly available if you want to go deeper on the Mamba-Transformer hybrid training methodology and benchmark methodology.

Bottom Line

Nemotron 3 Nano Omni is the most practical open option today for building multimodal agents that need to process video, audio, documents, and text in a single call. The free OpenRouter tier makes it worth adding to your evaluation stack this week — just watch the rate limits before committing to it for production traffic.

Sources: NVIDIA Technical Blog · NVIDIA Blog · Hugging Face Blog · vLLM Blog · MediaPerf / Coactive · Technical Report arXiv:2604.24954 · OpenRouter · AWS SageMaker JumpStart