NVIDIA published a walkthrough on July 23, 2026 showing how to customize its open-weight Nemotron 3 Nano language model on Prime Intellect Lab in roughly five to fifteen minutes, with total training costs under five dollars. In the demonstration, a Python math task jumped from 21.9 percent accuracy to 90.6 percent on the same 32 test problems after a short reinforcement learning run. For builders who assumed custom model training meant a GPU cluster and a machine learning team, this collapses the barrier to a coffee break and a few dollars.
What NVIDIA and Prime Intellect Shipped
Nemotron 3 Nano is a 30-billion-parameter open model (the A3B-BF16 checkpoint) in NVIDIA's Nemotron 3 family, a hybrid mixture-of-experts design built for agentic reasoning. The customization workflow runs on Prime Intellect Lab, a hosted training platform, so you do not provision or manage any GPUs yourself. The model weights are openly available, including the BF16 checkpoint on Hugging Face, and NVIDIA has open-sourced the wider stack around it: training data, recipes, and reinforcement learning environments.
The core idea is reinforcement learning from verifiable rewards, or RLVR. Instead of collecting human preference labels, you define a task where correctness can be checked automatically (a math answer, a passing unit test, a valid JSON shape) and let the model learn against that signal. Because the reward is computed, not annotated, the loop is cheap and fast.
The Numbers: 21.9% to 90.6% for Under $5
The demonstration is deliberately small so anyone can reproduce it. On a Python math benchmark of 32 problems, the base Nemotron 3 Nano scored 21.9 percent. After a short RLVR run training a LoRA adapter, the same model scored 90.6 percent on the same problems, a gain of 68.75 percentage points, for less than five dollars of compute. The Hugging Face writeup notes NVIDIA trained the released models across multiple verifiable environments at once, which produced smooth, uniform capability gains rather than lopsided spikes.
| Stage | Accuracy on 32 problems | Notes |
|---|---|---|
| Base Nemotron 3 Nano | 21.9% | Off-the-shelf, no task tuning |
| After RLVR LoRA run | 90.6% | Under $5 compute, 5 to 15 minutes |
| Improvement | +68.75 points | Same test set, verifiable reward |
Nemotron 3 Nano, Super, and Ultra: Which to Pick
The same workflow scales up without changing the steps. Nano is the entry point; Super and Ultra trade cost and latency for raw capability. Start on Nano to prove your task and reward function, then rerun the identical pipeline against a larger checkpoint once it works.
| Model | Parameters | Best for |
|---|---|---|
| Nemotron 3 Nano | 30B (A3B) | Prototyping, cheap iteration, edge and single-GPU serving |
| Nemotron 3 Super | 120B | Production tasks needing more headroom |
| Nemotron 3 Ultra | 550B | Maximum capability for hard reasoning workloads |
Because all three share the workflow, the cost of experimenting on Nano is essentially free relative to the payoff, and a validated recipe transfers straight to Super or Ultra.
How to Customize Nemotron 3 Nano Step by Step
The full loop, from cold start to a downloaded custom model, follows five steps:
- Establish a baseline. Run your evaluation set against stock Nemotron 3 Nano so you know the starting score. In the demo this was 21.9 percent.
- Define a verifiable reward. Write the check that scores an output as correct or not. Prime Intellect ships reusable RL environments you can start from instead of building one from scratch.
- Train a LoRA adapter with RLVR. Launch the reinforcement learning run on Prime Intellect Lab. LoRA keeps the trainable footprint tiny, which is why the run costs a few dollars rather than hundreds.
- Evaluate the delta. Re-run the same test set and compare. A large jump means the reward signal was well chosen; a flat result usually means the reward is too loose.
- Download and deploy. Export the customized model for local serving or push it through NVIDIA's tooling. NVIDIA's open NeMo RL toolkit covers the training internals if you want to go deeper.
What This Enables for Builders
The unlock is that task-specific model quality is no longer gated behind a research budget. If you can express "right versus wrong" as code, you can lift a small open model from unusable to reliable on your task for the price of lunch. That reframes when custom training makes sense: instead of reaching for a giant general model and a long prompt, you can specialize a 30B open model that runs on your own hardware and beats the generalist on the one thing you care about. Full Prime Intellect documentation covers the environment format, run configuration, and export paths.
For creative and agentic workflows specifically, the verifiable-reward pattern fits any task with a checkable output: structured data extraction, tool-call formatting, code that must pass tests, or constrained generation that must match a schema. Those are exactly the brittle spots where a general model wobbles, and a cheap RLVR pass can harden them.
Frequently Asked Questions
Do I need my own GPUs?
No. Training runs on Prime Intellect Lab's hosted infrastructure. You interact with the platform and download the resulting model; you do not provision hardware.
What does RLVR mean?
Reinforcement learning from verifiable rewards. You define a task whose correctness can be checked automatically, and the model learns against that computed signal instead of human preference labels, which makes the loop cheap and fast.
Is Nemotron 3 Nano really free to use?
The model weights are open and available on Hugging Face. The customization run in the demo cost under five dollars of compute on Prime Intellect Lab. Hosting and serving costs depend on where you deploy it.
Will this work for tasks other than math?
Yes, as long as you can write an automatic correctness check. Code that must pass tests, structured extraction, and schema-constrained generation all fit the verifiable-reward pattern.
Why LoRA instead of full fine-tuning?
LoRA trains a small adapter rather than all 30 billion parameters, so the run is fast and inexpensive while still shifting behavior substantially, as the 21.9 to 90.6 percent jump shows.
Can I scale the same recipe to bigger models?
Yes. The identical workflow applies to Nemotron 3 Super (120B) and Ultra (550B). Prove your task on Nano, then rerun against a larger checkpoint.
What to Do Next
Pick one narrow task where your current model is unreliable and where correctness is checkable in code. Establish its baseline on Nemotron 3 Nano, write the reward, and run a single RLVR pass. If the delta is large, you have a cheap specialization recipe you can now point at Super or Ultra. Start from the primary walkthrough and Prime Intellect's environment library rather than building the loop from zero.
