NVIDIA Nemotron 3.5 Super VL Hands-On: A New Open-Source Option for Visual Agents

NVIDIA has taken another step forward in its open-source model strategy. A developer on Reddit shared hands-on results from combining NVIDIA Nemotron 3.5 Super VL with the Deep Agents framework. The model integrates visual understanding, reasoning, and tool calling into a single set of weights, and is directly usable through LangChain's ChatNVIDIA interface.

Model Specs: 120B Total Parameters, Only 12B Active

Nemotron 3.5 Super VL uses a MoE architecture with 120B total parameters, but only activates 12B during inference. This design means it retains the capacity of a larger model while keeping actual compute overhead close to that of a mid-sized dense model.

On the capability front, it simultaneously supports visual input, reasoning chains, and tool calling—three abilities that previously required stitching together multiple specialized models. For agent scenarios, a single model covering multimodal input and action execution can significantly simplify pipeline complexity.

NVIDIA also provides a complete NeMo toolchain, allowing developers to post-train the model on their own data—a relatively uncommon offering among open-source models, and one that's friendly to teams needing domain adaptation.

MoE (Mixture of Experts) is a sparse-activation model architecture. It splits the feed-forward network into multiple parallel "expert" sub-networks, then uses a routing gating network to decide which experts process each token. A traditional dense model must pass every token through all parameters, whereas MoE activates only a small fraction, allowing the total parameter count to be very large (for knowledge storage capacity) while the compute cost per inference depends only on the activated portion. The industry commonly measures sparsity as "total parameters divided by activated parameters"; Nemotron 3.5 Super VL's 120B/12B works out to roughly 10x sparsity. The benefit of this design is stronger capability at equivalent compute, but the trade-off is that VRAM usage is still based on total parameters—deployment GPU memory requirements don't drop proportionally—and it places higher demands on routing network training stability and expert load balancing.

Test Performance: 87% Pass Rate on Behavior Suite

According to the original Reddit poster, Nemotron 3.5 Super VL achieved an average pass rate of 87% on their custom Deep Agents behavior test suite.

On the Harbor Unified-lite benchmark, its total task time was 55% less than DeepSeek^Ad V4.1 Flash, with comparable task success rates. What's interesting about this comparison is that the speed advantage is clear without any accuracy penalty. For production environments that need to call agents in bulk, a 55% time savings directly impacts cost structure.

The author also emphasized that these figures come from their own test suite and represent only a single data point—not an absolute cross-model ranking.

A behavior suite differs from traditional static Q&A benchmarks: rather than just checking whether a model answers a single question correctly, it has an agent complete a series of composite tasks with tools in a simulated environment, then calculates pass rates based on whether each task achieved its goal. This type of evaluation is closer to production scenarios because it simultaneously tests instruction following, multi-step planning, tool selection and invocation, and self-correction after errors. Correspondingly, its results are harder to compare across models: the task set, environment setup, and scoring criteria are all highly dependent on the author's customization, and other models may not have been run on the same suite—so 87% is better suited as a longitudinal version comparison or internal regression metric than as an authoritative cross-model ranking. This is also why the author stressed it "represents only a single data point."

Visual Capability Is the Key for Agent Scenarios

One line in the post deserves separate discussion: "Vision is the useful part for agents."

This observation hits a real pain point in current agent deployment. Most agent toolchains handle structured text—JSON from API responses, database query results, command-line output. But a huge amount of information in the real world exists as images: screenshots from customers, scanned contracts, phone photos of equipment failures, surveillance footage.

An agent that can directly read images, understand their content, and then execute operations with existing tools eliminates the intermediate steps of "OCR to text → understand → decide." Every conversion step removed means one less layer of information loss and latency.

By putting the visual encoder and tool-calling capability into the same model, Nemotron 3.5 Super VL makes this end-to-end image understanding-to-action chain feasible.

A vision-language model (VLM) typically consists of three parts: a visual encoder that splits images into patches, a projection layer that maps image features into the language model's token embedding space, and the language model backbone responsible for understanding and generation. The visual encoder cuts the image into patches and encodes them into a series of visual tokens, which are concatenated with text tokens and fed into the model together. To take a model from "understanding images" to "taking actions based on images," you also need to inject agent trajectory data with visual input during training, so it learns to select appropriate tools and generate valid invocation parameters after seeing an image. Compared to VLMs that only do image Q&A, these models have much higher requirements for training data formats—and it's a capability that's relatively scarce in the current open-source community.

What Open Weights + LangChain Integration Mean

Two engineering attributes of this model are worth noting:

Open weights mean it can be deployed locally, with data never leaving the internal network. For agents handling sensitive information like customer screenshots, this is a hard compliance requirement.

LangChain integration (via the ChatNVIDIA interface) lowers the barrier to entry. Teams with existing LangChain agents can swap in this model for comparison testing without major code changes.

NVIDIA's official documentation provides specific guidance for Python integration, so interested developers can get the workflow running directly.

LangChain is currently one of the more widely used frameworks for orchestrating agents and LLM applications. It abstracts different model providers' calling conventions through a unified Chat interface, making models replaceable like plugins. ChatNVIDIA is the integration component connecting to NVIDIA's model services. Beyond cloud APIs, it can also point to locally exposed OpenAI-compatible endpoints running through inference services like NIM or vLLM. For developers, this means switching models often requires only changing one line of initialization code—prompts, tool definitions, and agent loop logic stay largely unchanged for A/B comparison. Note, however, that framework-level compatibility doesn't equal behavioral consistency: different models' adherence to tool-calling formats and stability differences in multi-step tasks still need to be verified independently on real task sets.

Questions That Need Verification

The publicly available test data is still quite limited. The 87% pass rate and 55% time savings both come from a single source, with no third-party reproduction. Several areas worth watching:

• How does visual understanding actually perform on complex documents (multi-column layouts, handwriting, low-resolution screenshots)?
• Tool-calling stability and error recovery—more important in multi-step agent tasks than single-step accuracy
• Whether 12B activated parameters are sufficient in long-context scenarios

The original poster is also soliciting testing feedback from others, especially agent scenarios with image input. If you've actually run it, consider sharing your data in the original post.

One-line Summary

NVIDIA Nemotron 3.5 Super VL packs vision, reasoning, and tool calling into a single model with a 120B-total/12B-active MoE architecture.

Paragraph Summary

NVIDIA's open-source model Nemotron 3.5 Super VL was hands-on tested by a developer in combination with the Deep Agents framework. The model uses a MoE architecture with 120B total parameters but only 12B activated during inference. It supports visual input, reasoning chains, and tool calling, and comes with a NeMo post-training toolchain. It achieved an 87% average pass rate on a custom behavior test suite, and on the Harbor Unified-lite benchmark saved 55% task time versus DeepSeek V4.1 Flash with comparable success rates. The article emphasizes that visual capability is key to agent deployment—directly reading screenshots and document images and executing operations, eliminating the OCR intermediate step. Open weights support local deployment, and the LangChain ChatNVIDIA interface enables quick integration. However, the data comes from a single source, and complex document understanding and multi-step tool-calling stability still await third-party verification.