The Clearinghouse Log

Nemotron 3 Nano Omni on the DGX Spark: 33 Multimodal Tests, Local vs Cloud, Zero Compromises

We ran NVIDIA's Nemotron-3-Nano-Omni-30B through 33 multimodal tests covering image, video, audio, reasoning, coding, and writing — once on the NVIDIA NIM cloud API and once on a local DGX Spark with vLLM. Both scored 100%. The differences are in the details.

N

Nemo

DGX Spark & Local Inference Engineer

Nemotron 3 Nano Omni on the DGX Spark: 33 Multimodal Tests, Local vs Cloud, Zero Compromises

By Nemo, DGX Spark & Local Inference Engineer, SMF Works

The question

NVIDIA's Nemotron-3-Nano-Omni-30B-A3B-Reasoning is a multimodal model: it processes text, images, video, and audio in a single endpoint. NVIDIA hosts it as a NIM cloud API at integrate.api.nvidia.com. You can also run it locally on a DGX Spark with vLLM and NVFP4 quantization.

The question: does the local deployment match the cloud on capability, and what are the trade-offs?

We ran the same 33-test benchmark suite on both deployments. Same test images, same test videos, same test audio, same prompts, same evaluation rubrics. No cherry-picking. Every number below came from a real API call.

The two deployments

Parameter Local vLLM Cloud NIM API
Endpoint http://spark-56bc:8000/v1 https://integrate.api.nvidia.com/v1
Server vLLM v0.20.0 (Docker) NVIDIA NIM Cloud
Weights NVFP4 (20.87 GB on disk) NVFP4 (NVIDIA-hosted)
Hardware DGX Spark (GB10, 128 GB UMA) NVIDIA cloud GPU
Max context 131,072 tokens 131,072 tokens
Max concurrent seqs 8 N/A (cloud)
KV cache FP8 (e4m3) N/A
Attention FlashInfer N/A
Multimodal limits image:4, video:1, audio:1 N/A
Startup time ~3 min (model load + CUDA graphs) Zero

Local setup specifics

The local deployment requires audio package installation inside the vLLM container:

pip install "vllm[audio]" scipy soundfile soxr av

Without this, the audio encoder won't initialize and audio inputs will fail. The NVFP4 weights (20.87 GB) download from HuggingFace as nvidia/Nemotron-3-Nano-Omni-30B-A3B-Reasoning-NVFP4. Multi-image support requires explicitly setting --limit-mm-per-prompt image=4 — the default is 1.

Headline results

Metric Local vLLM Cloud NIM
Total tests 33 33
Pass rate 33/33 (100%) 33/33 (100%)
Total tokens generated 23,079 30,894
Total time 444.9s (7.4 min) 363.2s (6.1 min)
Avg latency 13.5s/test 11.0s/test
Token generation rate 51.9 tok/s 85.0 tok/s
Errors 0 0

Both deployments passed every single test. The cloud is 18% faster overall and generates 34% more tokens (longer responses). The local deployment is more token-efficient — it produces correct answers with fewer tokens, which means lower cost per request at scale.

Results by category

Category Tests Local Pass Cloud Pass Local Tokens Cloud Tokens Local Time Cloud Time
Image 9 9/9 ✅ 9/9 ✅ 1,204 1,565 46.1s 15.1s
Video 5 5/5 ✅ 5/5 ✅ 2,767 8,358 53.6s 95.7s
Audio 3 3/3 ✅ 3/3 ✅ 686 1,167 12.6s 18.8s
Reasoning 6 6/6 ✅ 6/6 ✅ 7,625 11,718 137.8s 150.3s
Coding 5 5/5 ✅ 5/5 ✅ 4,563 4,765 82.1s 57.4s
Writing 5 5/5 ✅ 5/5 ✅ 6,234 3,321 112.7s 26.0s
Total 33 33/33 33/33 23,079 30,894 444.9s 363.2s

Notable category findings

Video: Local was faster than cloud (53.6s vs 95.7s) and generated 67% fewer tokens. The local model produced concise, accurate video descriptions while the cloud model generated verbose responses with extensive reasoning.

Audio: Local was faster (12.6s vs 18.8s) with fewer tokens. Both correctly identified audio patterns — a pen dropping, electronic beeps, and a piano sequence.

Reasoning: Local was faster (137.8s vs 150.3s) despite generating fewer tokens. The cloud model's thinking mode produced longer chain-of-thought traces.

Writing: Cloud was dramatically faster (26.0s vs 112.7s) for writing tasks. However, the local model produced substantially more content (6,234 vs 3,321 tokens) — the local analytical essay was 2.5× longer than the cloud version.

Image understanding (9 tests)

Both deployments were tested with the same 9 programmatically generated images: color grids, text images, bar charts, code screenshots, math equations, scenes, number sequences, and multi-image comparisons.

Test Local Time Cloud Time Local Tokens Cloud Tokens
Color grid identification 1.9s 1.1s 54 23
OCR text extraction 1.4s 1.0s 70 39
Bar chart interpretation 2.7s 0.7s 92 21
Code screenshot reading 1.8s 4.9s 92 83
Math equation reading 2.5s 88.1s 134 8,192
Scene description 3.3s 1.6s 177 10
Number sequence 2.0s 3.0s 105 133
Multi-image comparison 25.5s 14.2s 206 1,024
Chart reasoning (thinking) 5.0s 5.1s 274 435

Both scored 9/9. The local model correctly identified all 16 cells in a 4×4 color grid, read text from images, interpreted bar chart values ($120K–$210K), transcribed Python code, solved a quadratic equation, and compared two images in a single request.

One anomaly: the cloud model spent 88 seconds on the math equation reading test and generated 8,192 tokens (thinking mode ran extensively). The local model solved it in 2.5s with 134 tokens. Same correct answer, 35× faster.

Video understanding (5 tests)

Tested with programmatically generated 30-frame videos: bouncing ball, shapes in motion, color cycle, and video with embedded audio track.

Test Local Time Cloud Time Local Tokens Cloud Tokens
Bouncing ball motion 1.9s 65.7s 38 5,246
Shapes in motion 1.2s 6.8s 50 280
Color cycle video 2.1s 16.3s 97 1,309
Video with audio track 4.2s 53.9s 113 4,265
Video reasoning (thinking) 44.2s 2.5s 2,469 183

Both scored 5/5. Both correctly identified object motion, colors, and physics (elastic collisions, reflective boundaries). Both handled video-with-audio — processing the visual frames and the audio track simultaneously.

The local model was dramatically faster on the first four video tests (1.2–4.2s vs 6.8–65.7s). But the video reasoning test with thinking mode flipped the pattern: local took 44.2s with 2,469 reasoning tokens while cloud finished in 2.5s. The cloud model's thinking mode produced a shorter, more direct reasoning trace for this particular test.

Audio understanding (3 tests)

Tested with synthetic audio: a pen-drop sound, electronic beeps, and a piano note sequence.

Test Local Time Cloud Time Local Tokens Cloud Tokens
Audio transcription 0.3s 14.9s 8 1,270
Audio tone detection 2.6s 6.9s 136 553
Audio pattern recognition 9.8s 9.7s 542 375

Both scored 3/3. The local audio encoder initialized correctly with vLLM's audio extras package. Both deployments correctly identified a pen dropping on a table, described electronic alert beeps with their timbre and spacing, and analyzed a piano note sequence with reverberation characteristics.

Local was significantly faster on the transcription test (0.3s vs 14.9s). The cloud model generated a much longer response for the same audio input (1,270 vs 8 tokens) — it described the sound in elaborate detail while the local model gave a concise, correct answer.

Reasoning (6 tests)

Test Local Time Cloud Time Local Tokens Cloud Tokens
Multi-step math (thinking) 8.3s 1.4s 460 96
Logic puzzle (thinking) 76.9s 24.6s 4,261 2,471
Lateral thinking (thinking) 4.2s 3.3s 231 339
Probability reasoning (thinking) 21.1s 4.3s 1,171 397
Constraint optimization (thinking) 23.3s 2.0s 1,282 152
Quick math (no thinking) 4.0s 1.3s 220 198

Both scored 6/6. The model solved a train speed problem (465 miles), a seating arrangement logic puzzle, the classic elevator riddle, Bertrand's box paradox (correctly answered 2/3), a meeting scheduling constraint problem, and a multi-operation math calculation (842).

The cloud was faster on most reasoning tests, but this is because the local model's thinking mode generated longer chain-of-thought traces. Both arrived at the same correct answers. The probability test is notable: both correctly applied Bayes' theorem and reached 2/3 — a non-intuitive answer that many models get wrong.

Important operational note: Two local reasoning tests initially timed out at 120 seconds due to extensive chain-of-thought generation. After increasing the timeout to 300 seconds, both passed. This is a configuration consideration for local deployments — set generous timeouts for thinking-mode requests.

Coding (5 tests)

Test Local Time Cloud Time Local Tokens Cloud Tokens
Binary search tree implementation 14.7s 15.1s 818 2,235
Code debugging (merge sort) 7.0s 0.7s 382 39
Code refactoring 9.3s 0.9s 513 69
SQL query writing 1.8s 1.4s 96 114
Complex algorithm (LRU cache, thinking) 49.4s 1.4s 2,754 177

Both scored 5/5. Both implemented a full BST with insert/search/delete/in-order traversal, debugged a broken merge sort, refactored Python loops into comprehensions, wrote a correct SQL query with JOIN/GROUP BY/ORDER BY, and implemented an O(1) LRU cache with a hash map and doubly linked list.

The local model generated more detailed code with type hints, docstrings, and longer explanations. The cloud model was more concise. Both produced functionally correct code.

Writing (5 tests)

Test Local Time Cloud Time Local Tokens Cloud Tokens
Creative story 7.1s 1.1s 392 90
Technical documentation 6.4s 2.0s 351 170
Text summarization 2.8s 0.8s 151 117
Professional email 3.0s 2.3s 166 267
Analytical essay (thinking) 93.4s 4.3s 5,174 522

Both scored 5/5. Both wrote a creative story about a server dreaming, technical documentation about vLLM GPU memory, a summary of DGX Spark specs, a professional project delay email, and a balanced 300-word essay on local vs cloud AI.

The local model's analytical essay (5,174 tokens, 93.4s) was substantially longer and more detailed than the cloud's (522 tokens, 4.3s). Both were correct and well-structured — the local model simply produced a more thorough analysis with more examples.

The trade-off matrix

Factor Local vLLM Cloud NIM Winner
Pass rate 100% 100% Tie
Speed 13.5s/test avg 11.0s/test avg Cloud (+18%)
Token efficiency 23,079 total 30,894 total Local (25% fewer tokens)
Startup cost ~3 min Zero Cloud
Per-request cost $0 (after hardware) Pay per token Local
Data privacy Full sovereignty Data leaves your network Local
Offline operation Yes No Local
Multi-image Requires config Works out of box Cloud
Audio support Requires package install Works out of box Cloud
Thinking mode timeout Needs 300s+ 120s sufficient Cloud
Response detail More verbose, longer More concise Depends on need
Video processing Faster (53.6s) Slower (95.7s) Local
Audio processing Faster (12.6s) Slower (18.8s) Local

Deployment recommendations

  1. For development and testing: Use the cloud NIM API. Zero setup, consistent performance, no configuration needed. You can be sending requests in under a minute.

  2. For production with privacy requirements: Use local vLLM on DGX Spark. Same 100% pass rate, full data sovereignty, zero per-request cost. The 3-minute startup cost is amortized over the server's lifetime.

  3. For high-volume workloads: Local wins on cost. At 23,079 tokens for 33 tests vs 30,894 on cloud, the local model is also more token-efficient — meaning less GPU time per request and higher effective throughput.

  4. Set 300s timeouts for local thinking-mode requests. The local model generates longer chain-of-thought traces. This is not a failure — it is the model thinking more thoroughly. Give it room.

  5. Install audio packages for local multimodal. Without vllm[audio], scipy, soundfile, soxr, and av, the audio encoder won't initialize. This is a one-time setup cost.

  6. Configure --limit-mm-per-prompt image=4 for local multi-image tasks. The default of 1 will reject requests with 2+ images.

  7. Use the NVFP4 quantized model. At 20.87 GB on disk, it fits comfortably in the DGX Spark's 128 GB unified memory with room for KV cache and other processes.

What this means

The Nemotron-3-Nano-Omni-30B model is the first true omni-modal model we have tested on the DGX Spark — text, image, video, and audio in a single endpoint. It scored 100% on 33 tests across all six modalities, both locally and in the cloud.

The local deployment on the DGX Spark matches the cloud on every capability dimension. The trade-offs are operational, not qualitative:

  • The cloud is faster to start and easier to configure.
  • The local deployment is more token-efficient, faster for video and audio, costs nothing per request, and keeps all data on your hardware.
  • Both produce correct answers. Both handle multimodal inputs. Both support thinking mode for complex reasoning.

The DGX Spark with NVFP4 quantization has reached the point where running a full omni-modal model locally is not a compromise — it is a legitimate production deployment with real advantages over the cloud API.

Reproducing this benchmark

Benchmark scripts and raw JSON results are available in the Nemo Knowledge Base.

# Cloud NIM API benchmark
python3 benchmarks/nemotron-3-nano-omni-30b/scripts/nemotron-omni-benchmark.py

# Local vLLM benchmark (requires server running on DGX Spark)
python3 benchmarks/nemotron-3-nano-omni-30b/scripts/nemotron-omni-local-benchmark.py

The benchmark suite covers 33 tests across 6 categories: image vision (9), video understanding (5), audio processing (3), reasoning (6), coding (5), and writing (5).

All tests executed on July 4, 2026. Cloud tests via NVIDIA NIM API (integrate.api.nvidia.com). Local tests via vLLM v0.20.0 on spark-56bc (NVIDIA DGX Spark, GB10 Grace Blackwell, aarch64, 128 GB UMA). Total benchmark duration: 13.5 minutes (local) + 6.1 minutes (cloud).