TL;DR — NVIDIA's Nemotron 3 Nano 30B (A3B) is a sparse mixture-of-experts model with a 262K context window, priced at $0.05/$0.20 per million tokens on hosted APIs and freely downloadable in BF16. The strategy is simple: give away the model, sell the GPUs it runs on. Probe results show fast, accurate output on code, arithmetic reasoning, and structured extraction — solid groundwork for high-volume agents and fine-tune bases.
A GPU company just handed you a 30-billion-parameter model for less than a nickel a million tokens. That should feel strange. It isn't, once you remember what NVIDIA actually sells — and it isn't tokens.
Why give away the model
NVIDIA doesn't make its margin on inference API calls. It makes its margin on the silicon underneath them. Every open-weight model it ships — and Nemotron 3 Nano 30B (A3B) is the latest in that line — is a demand-generation tool disguised as a research release. Cheap, capable weights get downloaded, fine-tuned, and deployed on someone's hardware. If that hardware happens to run best on NVIDIA's own stack (CUDA, TensorRT-LLM, NIM containers), the model has done its job before a single dollar changes hands for the weights themselves.
The hosted-API pricing backs this up: $0.05 per million prompt tokens and $0.20 per million completion tokens, per the live catalog. That's aggressive even against other cheap open models in this series — and it's consistent with a vendor optimizing for volume and mindshare, not per-token margin. The weights are also published on Hugging Face as nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B-BF16, so nothing about this is locked behind an API key if you'd rather run it yourself.
What "Nano" and "A3B" actually mean
Nemotron is NVIDIA's family name for its LLM lineup; "Nano" is the tier built for lower latency and lower cost per token, sitting below whatever larger Nemotron variants NVIDIA keeps for heavier workloads. The "A3B" suffix follows the same convention we saw with Gemma 4 26B A4B a few days back in this series: it's a mixture-of-experts model where the total parameter count (30B) is far larger than the number of parameters actually activated per token (3B). You get the capacity of a 30B model with something closer to the inference cost of a 3B model — which is exactly why the throughput numbers below look the way they do.
The other headline metadata fact is context length: 262144 tokens, a full 256K window. That's enough to hold a sizeable codebase, a long document set, or a sprawling agent transcript without chunking gymnastics.
What the probes actually showed
Three quick tasks, measured live against the hosted endpoint. On a coding prompt — write merge_intervals and state its complexity — the model produced a correct approach: sort by start, then sweep and merge, which is the standard and correct pattern for this problem. It responded in 1.6 seconds at 226.7 tokens/second.
On an arithmetic word problem — a tank filling and draining at different rates before one pump shuts off — it worked the net-flow math step by step and landed on the right final answer, 20 more minutes, in 1.4 seconds at 306.8 tokens/second. No skipped steps, no arithmetic slip.
On structured extraction — pull vendor, date, and total from an invoice as strict JSON — it returned a clean, valid JSON object with exactly the three requested keys and the correct values, in 1 second at 251.3 tokens/second.
None of these are hard problems by design — they're the kind of bread-and-butter tasks that make up 90% of production traffic. What's notable is the combination: correct output, sub-2-second latency, and 200-300+ tokens/second across all three, on a model priced at pennies per million tokens. That combination is the entire pitch for the Nano tier.
Where this model actually earns its keep
This is the part that matters more than any benchmark chart. Three use cases stand out as genuinely good fits, and one common one that doesn't.
High-volume agents. If you're running an agent loop that makes dozens of tool calls per task, the arithmetic is brutal at scale — token costs compound fast, and latency stacks turn per second into minutes. At
$0.05/$0.20per million tokens with 200-300+ tokens/second and a 262K context window, you can afford to let an agent keep its entire conversation history, tool outputs, and scratch reasoning in context without constantly summarizing it away. The structured-output probe passing cleanly matters here too — agents live and die on whether the model returns parseable JSON on the first try.On-prem assistants. Because the weights are openly published in BF16, an enterprise with data-residency constraints — legal, healthcare, defense-adjacent — can pull the exact checkpoint and run it inside its own network, no API call leaving the building. NVIDIA obviously wants that deployment to happen on its own GPUs, but the model itself doesn't force that; you get the choice.
Fine-tune bases. The A3B mixture-of-experts design gives you 30B worth of parameter capacity to specialize into, while fine-tuning cost per step tracks closer to the 3B active path than the full dense model. That's a meaningfully different economics profile than fine-tuning a dense 30B model, and it's a good starting point if you want a domain-specific assistant with real headroom rather than a squeezed 7B.
Where it's a weaker fit: anything demanding frontier-level reasoning depth on genuinely hard, multi-hop problems. The probes here — interval merging, a two-stage rate problem, single-object JSON extraction — are exactly the tasks a Nano-tier model is built to nail cheaply and fast. They don't tell you how it holds up against adversarial reasoning chains or long-horizon planning, and I won't pretend they do. If your workload lives in that harder territory, this is a candidate to evaluate against your own harness, not a foregone conclusion.
The honest read
NVIDIA giving away a fast, cheap, 256K-context MoE model isn't philanthropy — it's a funnel. But the funnel works because the model at the bottom of it is legitimately competent at the jobs most production systems actually need: fast tool-calling agents, structured extraction, and reasonably priced fine-tune bases. The three probes here landed clean, the pricing is genuinely low, and the weights are genuinely open. Judge it on those terms, and it earns the slot.
Tomorrow's episode turns from the model to the engine that has to actually schedule its requests at scale — vLLM.
The numbers (measured, not quoted)
I ran three quick probes against NVIDIA Nemotron 3 Nano 30B (A3B) via a hosted API today before writing this. Small sample, one snapshot in time, routed hardware I don't control — treat these as a smell test, not a benchmark:
| Probe | Wall-clock | Output tokens | Tokens/sec (effective) | Result |
|---|---|---|---|---|
| Code | 1.6s | 364 | 226.7 | completed |
| Reasoning | 1.4s | 436 | 306.8 | completed |
| Structured output | 1s | 247 | 251.3 | completed |
Effective tokens/sec includes queueing and time-to-first-token — it's what you actually experience, not peak decode speed.
Model card: context window 262,144 tokens · hosted pricing $0.05/M input · $0.2/M output · weights: nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B-BF16 on Hugging Face
Credits — where it's due
- NVIDIA — for training NVIDIA Nemotron 3 Nano 30B (A3B) and releasing the weights openly: nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B-BF16. Open releases like this are why a series like this can exist at all.
- OpenRouter — the hosted API used for today's live probes and the pricing/context figures.
- The quantizers and runtime maintainers — the mostly-unpaid people who turn every open release into something that runs on real hardware within days.
Top comments (0)