NVIDIA Nemotron 3.5 Super VL Lands on Ollama: 5x Agent Throughput on a Single GPU

NVIDIA's vision-language model Nemotron 3.5 Super VL has officially arrived on Ollama, and developers can now run this model — which combines reasoning with visual understanding — locally with a single command: ollama run nemotron-3.5-super. NVIDIA claims that on a single GPU, the model's throughput on agent tasks can reach up to 5x that of open-source models of the same size.

Model Positioning: A Vision-Language Model Built for Agent Workflows

Nemotron 3.5 Super VL is neither a pure image-recognition model nor a text-only reasoning model. Instead, it fuses visual understanding with multi-step reasoning into agent workflows. This means it can accept image input, parse scenes and extract information, and then use that as a basis for planning, tool calling, and other tasks that require continuous reasoning.

In its tweet, NVIDIA emphasized that the model targets "a range of agent workflows." Combined with its visual capabilities, typical applications include GUI automation, document and chart understanding, and multimodal Q&A. These tasks often require the model to switch back and forth between perception and decision-making, placing higher demands on reasoning efficiency and context management.

Vision-language models (VLMs) are a class of model architecture that accepts both image and text input and outputs text. A typical approach uses a vision encoder (such as ViT) to split an image into patches and encode them into a sequence of vectors, then aligns these visual tokens with the representation space of a large language model via a projection layer or cross-attention, feeding them into the decoder alongside text tokens. As a result, a VLM's capability boundary depends not only on the language backbone but also on the quality of image-text alignment and its visual resolution strategy. Compared with pure image classification or OCR models, VLMs can flexibly specify tasks using natural language instructions; compared with text-only LLMs, they have an additional perception channel, making them suitable for scenarios that require "looking at an image to make decisions."

Agent workflows refer to a model not just giving an answer in a single round of Q&A, but iteratively executing "observe—reason—act": parsing the current state (such as a screen capture or a tool's returned result), planning the next step, calling tools (clicking, retrieving, reading and writing files), and then continuing to make decisions based on new observations until the task is complete. This paradigm places requirements on models that differ markedly from chat scenarios: it needs stable structured output (such as tool-calling parameters), longer context to retain historical observations, and lower per-call inference latency — because a single task often requires dozens of model calls, and the end-to-end experience is the product of per-call latency and the number of calls.

Performance Highlights: Single-GPU Throughput Up to 5x That of Comparable Models

The core figure NVIDIA provides is that on a single GPU, Nemotron 3.5 Super VL's throughput on agent tasks can reach up to 5x that of other open-source models of the same size. Throughput is especially critical for agent applications — agents typically require multiple model calls to complete a task, so an increase in per-call inference speed directly amplifies into improved end-to-end task completion efficiency.

If this metric can be reproduced under real workloads, it means that under the same hardware conditions, higher-concurrency agent services can be supported, or the per-task cost can be reduced at the same throughput. Note, however, that 5x is an upper-bound figure measured by NVIDIA under specific benchmarks and configurations; actual performance will vary by task type, batch size, and hardware environment.

Throughput and latency are two metrics that are easily confused. Latency refers to the time it takes for a single request from being sent to being returned, while throughput refers to the number of requests a system can complete or the number of tokens it can generate per unit of time, typically measured in tokens/s or requests/s. Throughput can be improved through batching, KV cache reuse, quantization, speculative decoding, and other techniques, but increasing batch size often comes at the expense of per-request latency. What makes agent scenarios special is that they involve many concurrent requests and a high proportion of images and historical context in the input, so the prefill stage accounts for a large share of the overhead. Optimizations targeting this stage often yield greater throughput gains than decoding acceleration. When evaluating multipliers like 5x, it's necessary to confirm the benchmark's batch size, sequence length, whether parallelism is enabled, and the specific model versions being compared.

Ollama Ecosystem Support: Lowering the Barrier to Local Deployment

Ollama has become one of the de facto standard tools for running open-source large models locally, with its advantage lying in an extremely simple model-pulling and running experience. Nemotron 3.5 Super VL joining the Ollama model library means developers can try out this vision-language model locally or in private environments without having to deal with complex inference framework configuration themselves.

For teams concerned about data privacy or needing to deploy agents in offline environments, this channel reduces evaluation costs. Developers can first validate the model's performance in their own business scenarios using a small number of samples, and then decide whether to invest more resources in scaled deployment.

Ollama is an open-source local model runtime that wraps model weight downloads, quantized format (GGUF) loading, hybrid GPU/CPU inference, and a unified HTTP API (listening on port 11434 by default), and also provides an OpenAI-compatible interface. It packages model weights, prompt templates, and parameter configurations into a Modelfile, so that a single ollama run command completes both pulling and launching. For multimodal models, Ollama accepts Base64-encoded images via the API's images field. Note that the actual VRAM usage of local runs is closely tied to the quantization level (such as Q4 or Q8), and quantization introduces precision loss, so community-measured throughput and accuracy may differ from NVIDIA's FP16 benchmarks.

What It Means for Developers

The combination of vision-language models and agent frameworks is becoming a hot direction in the open-source community. By distributing Nemotron 3.5 Super VL through Ollama, NVIDIA has brought its engineering optimizations in multimodal reasoning within reach of individual developers and small teams.

The next thing to watch is community testing: whether the 5x throughput improvement holds up consistently across different GPU models and agent frameworks, and how accurate the model is on specific tasks such as GUI operations and chart understanding. These data points will determine whether it can go from "worth a try" to "production-ready."

One-line Summary

NVIDIA's vision-language model Nemotron 3.5 Super VL is now on Ollama, with NVIDIA claiming 5x agent throughput on a single GPU.

Paragraph Summary

NVIDIA's vision-language model Nemotron 3.5 Super VL is now officially available on Ollama, and developers can run it locally with the single command ollama run nemotron-3.5-super. The model is neither a pure image-recognition model nor a text-only reasoning model; instead, it fuses visual understanding with multi-step reasoning into agent workflows, handling tasks such as GUI automation, document and chart understanding, and multimodal Q&A that require switching back and forth between perception and decision-making. The core figure NVIDIA provides is that single-GPU agent-task throughput can reach up to 5x that of same-size open-source models, which would directly amplify end-to-end task efficiency. Distribution through Ollama further lowers the barrier to local evaluation and private deployment, but 5x is an upper-bound figure under specific benchmarks, and actual performance still needs to be validated by the community under real workloads.