I tried NVIDIA Nemotron 3 Ultra

Hello, I'm Morishige from Classmethod's Manufacturing Business Technology Department.

NVIDIA's Nemotron 3 family has gained a top-tier Ultra model. With a size of 550B, it was released on June 4, 2026.

https://developer.nvidia.com/blog/nvidia-nemotron-3-ultra-powers-faster-more-efficient-reasoning-for-long-running-agents/

Up until now, I've been working through the Nemotron series on DGX Spark, starting from the smaller models. I was able to run locally up to the 120B-class Super, but the Ultra this time is on a completely different scale. Needless to say, the 128GB of DGX Spark can't even hold the weights...

Nemotron 3 is made available by NVIDIA itself through a free API, and even models that can't be run locally can be accessed via browser. In this article, I'll confirm what kind of environment Ultra requires, verify it using that free API, and finally organize "which model to use and how" including Nano and Super.

What Kind of Model Is Nemotron 3 Ultra

It's a MoE with 550B total parameters, with 55B active per token. The architecture is called LatentMoE, a hybrid configuration combining Mamba-2, Transformer, and MoE.

What NVIDIA is aiming for with this model is the long-running agent. In their technical blog, they described it as "single-turn chatbots evolving into long-running agents." Agents plan, call tools, spin up sub-agents, and continuously feed back their history and reasoning to the model. The longer the task, the more tokens this exchange consumes, and the greater the drift between cost and goal. Ultra feels designed to push through that with efficiency. NVIDIA's intended use cases are also agents that run for hours—complex coding, long-form research, and internal workflow automation.

The division of roles in the hybrid architecture was personally the most interesting part. Mamba layers efficiently handle long contexts, while Transformer layers take on the role of "accurately recalling specific facts from within a large context." Additionally, MTP (Multi-Token Prediction) predicts multiple tokens at once, boosting throughput for long outputs. Combined with NVFP4 quantization, inference throughput is said to be up to 5x faster and operational costs when running agents up to 30% lower compared to other open models of the same class. The efficiency gains grow the longer you run it.

One important note here: Ultra is text-only. Since Nano Omni in the same family is multimodal, you might assume images are supported too, but Ultra accepts neither images nor audio. The highlights are its 1M token long context and reasoning capability. The license is OpenMDW 1.1, which permits commercial use.

In official benchmarks, the numbers include 91% on PinchBench for agent productivity, 82% on IFBench for instruction following, and 95% on Ruler's 1M context. Even with NVFP4, degradation from BF16 is at most 2–3 points, and some items actually exceed BF16—reassuring for those of us planning to use the quantized version as a baseline.

System Requirements to Run Ultra

Since 550B is clearly too large for DGX Spark, let's look at what kind of environment is actually assumed.

Even with NVFP4 quantization, the weights alone are approximately 335GB. The minimum configuration NVIDIA lists is 4× B200 or 8× H100 80GB in a single node. For GB200 or GB300, 4 cards minimum. That's over 600GB of VRAM, making this a datacenter-grade GPU prerequisite. The weights alone are 2.6× the 128GB of DGX Spark, so they're simply in different leagues.

DGX Spark can handle up to the Super class. Ultra is one step above that, requiring a multi-GPU server.

However, this barrier is also the flip side of what makes Ultra uniquely appealing. Ultra has its weights, training data, and recipe all publicly released—if you can provision a server of this class, you can run a 550B frontier model entirely in your own environment. You can use it freely without worrying about per-token usage charges, and you're free to fine-tune or customize it on internal data. Cloud APIs are convenient, but the data you input goes to an external party. On the other hand, if you can operate entirely within your own or your country's data center, even fields like manufacturing, healthcare, and government where sensitive data can't leave the premises can use top-tier models with confidence. This is what's called sovereign AI—running models while keeping data under your own control. I've been saying it's a size that can't be run locally, but the flip side is that with the right hardware, you can keep it in your own hands—and that feels quite significant.

So Where Do You Run It

If local is impossible, you have to borrow someone else's setup. Nemotron 3 Ultra was made available through quite a wide range of channels simultaneously with its release.

NVIDIA's technical blog mentioned clouds such as SageMaker JumpStart, Google Cloud, Microsoft Foundry, and Oracle Cloud as distribution channels. However, since I couldn't track down Ultra-specific pages in each provider's catalog myself, I'll use the most accessible option—the free API at build.nvidia.com.

There's also an interesting channel for agent use cases. Nous Research, the developers of Hermes Agent, joined NVIDIA's Nemotron Coalition and partnered with Nebius to open up Nemotron 3 Ultra free for 2 weeks (June 4–18) on Nous Portal. With Hermes Agent, whether Desktop or CLI, you just select nvidia/nemotron-3-ultra:free as the model. I previously wrote an article about running Hermes Agent on DGX Spark's OpenShell with NemoHermes, so you can run 550B straight from Hermes. Being able to immediately try Ultra—designed for long-running agents—directly from an agent execution platform seems like a great fit.

Trying It Out with the Free build.nvidia.com API

The API is OpenAI-compatible, so you can call it simply by swapping the base URL and model ID in the openai client.

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://integrate.api.nvidia.com/v1",
    api_key=os.environ["NVIDIA_API_KEY"],
)

resp = client.chat.completions.create(
    model="nvidia/nemotron-3-ultra-550b-a55b",
    messages=[{"role": "user", "content": "あなたのモデル名と開発元を1文で答えてください。"}],
    max_tokens=256,
    temperature=0.2,
    extra_body={"chat_template_kwargs": {"enable_thinking": False}},
)
print(resp.choices[0].message.content)

This returns "I am Nemotron 3 Ultra, a language model developed by NVIDIA researchers." The response came back in under a second. You can call a 550B model from your own MacBook with just a few lines of code.

What's interesting is the behavior in reasoning mode. When you set enable_thinking to True, the thought process is returned separately in a field called reasoning_content. For example, when I posed the classic question "Lotus leaves double every day and cover the pond on day 48. On which day is the pond half covered?", the reasoning_content contained this:

If it doubles every day, then one day prior to being full,
it must have been half full. So, Day 47.

And the main response returned "Day 47" in Japanese. In this case, the reasoning was done in English, with only the final answer switching to Japanese. A very multilingual model-like behavior—nice to see.

Comparing Nano, Super, and Ultra Side by Side

Since I can call Nano (30B-A3B) and Super (120B-A12B) through the same API, I lined up all three generations on Japanese reasoning problems. I started with 8 basic questions involving inclusion-exclusion and simultaneous equations, but all three models solved them without difficulty—no differentiation at all.

So I remeasured with 8 more challenging questions, including large-number inclusion-exclusion, combinations, and counting perfect squares and cubes. Here are the results.

The one question dropped was one where my phrasing "how many common solutions are there" could also be read as "how many solutions," and all three models answered it the same way. In practice, it's a tie at full marks.

Average latency per question for the easy and hard sets of 8. In both sets, Nano is fastest, with larger models taking more time.

Ultra's True Strength Is Long Context

Its real strength lies in long context. I ran needle-in-haystack tests—embedding a single passphrase somewhere in a long Japanese text and asking for it at the end—varying both the position of the passphrase (beginning, middle, end) and the length of the text (approximately 6,000 to 600,000 tokens).

Results of attempting to retrieve a passphrase placed at the beginning, middle, or end across 5 different lengths. Green indicates success; cell numbers show response time in seconds.

The result was 14 out of 15 cells succeeded. Even in a 600,000-token document, it accurately extracted the passphrase from the beginning, middle, or end in about 35 seconds. The single failure—"near beginning × ~6,000 tokens"—was consistently retrieved on re-tests, so it was just noise. Pushing further to exactly 1M triggered an upper-limit error, confirming that approximately 1 million input tokens are available. While many hosted services cap at 256K by default, the API catalog version allows the full 1M from the start.

NVIDIA themselves have published quality figures. On the 1M version of Ruler, which measures targeted information retrieval from long texts, Ultra scores 95%. This aligns with my hands-on experience of reliable extraction up to 600,000 tokens, and this capacity and stable extraction should really pay off for agents running with hundreds of thousands of tokens of history. Score details are in the technical blog linked at the beginning of this article.

What Is Ultra Actually For

After all this exploration, what I felt is that Ultra isn't simply "a bigger version of Nano or Super"—its positioning is fundamentally different. Nano and Super are everyday models you load onto DGX Spark and run locally, and as we saw, even 30B-class handles basic Japanese reasoning just fine. The everyday smarts are already sufficient in small models today.

What Ultra takes on is everything beyond that. At 550B, it doesn't fit locally and presupposes datacenter-grade GPUs. Its target is autonomous agents that run for hours without stopping—handling complex coding, long-form research, and internal workflow automation. Carrying long context and chains of tool calls while staying on goal. That's what this platform is for.

Viewed from this positioning, the numbers from testing make sense. The 1M long context proved capable of retrieving a passphrase from 600,000 tokens away, wherever it was placed. Inference is said to be up to 5x faster and agent operational costs up to 30% lower than other open models of the same class. The efficiency that compounds the longer you run it is built for long-running agents whose token counts balloon. Furthermore, with weights, data, and recipe all published, if you have the hardware you can run it entirely within your own data center. No per-token billing to worry about, no sensitive data leaving the premises, and the highest-tier models under your own control. That is Ultra's strength.

Summary

I've worked through Nemotron 3 from Nano on DGX Spark, and with Ultra I've crossed the ceiling of what local hardware can handle. What I've learned is that Ultra isn't "the biggest model that can't run locally"—it's "a model for running long-running autonomous agents continuously, faster, cheaper, and under your own control." Now that small models are smart enough for basic tasks, Ultra's role is to withstand token explosions and keep running without stopping. Even if you can't run it locally, you can try it immediately via the free API. If you're curious, start by touching the 550B model at build.nvidia.com.

Reference Links

• Nemotron 3 Ultra Model Card (Hugging Face): https://huggingface.co/nvidia/NVIDIA-Nemotron-3-Ultra-550B-A55B-NVFP4
• NVIDIA Technical Blog: https://developer.nvidia.com/blog/nvidia-nemotron-3-ultra-powers-faster-more-efficient-reasoning-for-long-running-agents/
• Ultra page on build.nvidia.com: https://build.nvidia.com/nvidia/nemotron-3-ultra-550b-a55b
• Nemotron 3 Super DGX Spark Deployment Guide: https://docs.nvidia.com/nemotron/nightly/usage-cookbook/Nemotron-3-Super/SparkDeploymentGuide/README.html