# NVIDIA Nemotron 3 Ultra in OpenCode: Benchmarks and a Free Setup Guide

> What NVIDIA Nemotron 3 Ultra really scores, plus a step-by-step guide to install OpenCode, get a free NVIDIA API key, add the NIM provider, and select the model.

Canonical: https://www.agentickit.co/blog/nemotron-3-ultra-opencode-guide
Last updated: 2026-08-20

NVIDIA put a 550B open-weight frontier reasoning model behind a **free API key** at build.nvidia.com, and opencode is an OpenAI-compatible terminal agent that will happily point at it. That combination is the reason this guide exists.

The pitch: **a free 1M-context coding model, in a free terminal agent, in about five minutes.** This guide is the full walkthrough: what the model actually is, what the benchmarks say (including where it loses), and every command you need end to end.

## TL;DR: the four commands

```bash
# 1. install opencode
curl -fsSL https://opencode.ai/install | bash

# 2. get a free key at https://build.nvidia.com  (starts with nvapi-)

# 3. add NVIDIA as a provider (config below), then:
opencode

# 4. inside opencode:
/model nvidia/nvidia/nemotron-3-ultra-550b-a55b
```

Everything below is the detail behind those four lines.

## What Nemotron 3 Ultra actually is

NVIDIA released Nemotron 3 Ultra on **June 4, 2026**, after announcing it at Computex 2026. It is open-weight and downloadable on Hugging Face, which is the part that matters. This is not a closed API-only frontier model.

| Spec | Value |
| --- | --- |
| Total parameters | 550B |
| Active parameters | 55B (Mixture-of-Experts) |
| Architecture | Hybrid Mamba-Transformer MoE with LatentMoE routing |
| Context window | Up to 1,000,000 tokens |
| Quantization | Pretrained in NVFP4 (runs on Ampere, Hopper, Blackwell) |
| Extras | Multi-token prediction layers, native speculative decoding, inference-time reasoning budget control |
| Model ID | `nvidia/nemotron-3-ultra-550b-a55b` |
| Release | June 4, 2026 |

The design goal NVIDIA states out loud is **long-running agents**: the Mamba layers keep long sequences cheap, the Transformer layers keep fact retrieval sharp, and the MoE routing means you pay for 55B of compute, not 550B. The [NVIDIA technical blog](https://developer.nvidia.com/blog/nvidia-nemotron-3-ultra-powers-faster-more-efficient-reasoning-for-long-running-agents/) frames the whole model around agentic cost-per-task rather than raw leaderboard position.

That framing is the tell. This is a model built to run in a loop for an hour without bankrupting you, which is exactly the opencode use case.

## Benchmarks, with the losses included

Two things to know before reading any table: benchmark numbers for this model vary by source and by reasoning budget, and NVIDIA's own reported ranges are wider than a marketing page usually admits.

**NVIDIA's reported numbers** ([technical blog](https://developer.nvidia.com/blog/nvidia-nemotron-3-ultra-powers-faster-more-efficient-reasoning-for-long-running-agents/)):

| Benchmark | Score |
| --- | --- |
| SWE-Bench Verified | 65-70.4% |
| Agent productivity (PinchBench) | 91% |
| Instruction following (IFBench) | 82% |
| Long context (RULER @ 1M) | 95% |
| Long-horizon planning (EnterpriseOps-Gym) | 33% |

**Third-party aggregation** ([BenchLM](https://benchlm.ai/models/nemotron-3-ultra)) puts SWE-bench Verified at 71.9%, LiveCodeBench v6 at 89.0%, MMLU-Pro at 86.8%, and IFBench at 81.7%, but ranks the model **#154 of 221 overall**, with agentic tool use at #120 of 134 and coding at #108 of 138.

Those two paragraphs are the whole story. Read them together:

- **Where it is genuinely strong:** instruction following (top-5 in its category), long-context retrieval, single-shot code generation, and raw throughput. NVIDIA claims 5.9x, 4.8x, and 1.6x higher inference throughput than GLM-5.1-754B, Kimi-K2.6-1T, and Qwen-3.5-397B on 8k-in/64k-out, and ~30% lower cost-to-completion on SWE-Bench and Terminal-Bench 2.0 because it burns fewer tokens per turn.
- **Where it is weak:** multi-step agentic tool use and long-horizon planning. A 33% on EnterpriseOps-Gym is not a typo. Long-horizon planning is genuinely hard, and this is not where a 550B open model beats a frontier closed model.

### So did it kill Claude Code?

No, and the category error is worth naming, because it changes how you should use this.

**Claude Code and Codex are harnesses. Nemotron 3 Ultra is a model.** Claude Code is a terminal agent that happens to run Claude; opencode is a terminal agent that runs whatever you point it at. The correct comparison is *opencode + Nemotron 3 Ultra* vs *Claude Code + Claude*, and the result is exactly what the benchmarks predict:

| Job | Honest verdict |
| --- | --- |
| Generate a file, a function, a migration | Nemotron 3 Ultra is completely fine, and free |
| Read a 300k-token codebase and answer questions | Strong. The 1M context and RULER score are real |
| Refactor across 20 files in one unattended loop | Frontier models still win; agentic tool use is the weak column |
| Overnight "make CI green" | Use a paid frontier model, or expect to babysit |
| Learning, side projects, unlimited experimentation | Nemotron wins on price, which is zero |

If your monthly AI bill is the thing stopping you from shipping, this stack removes it. If your bottleneck is a hard multi-file refactor, it does not.

The rest of this guide is the setup, which is the same either way.

## Step 1: Install opencode

opencode is an open-source terminal coding agent. Pick one:

```bash
curl -fsSL https://opencode.ai/install | bash
```

```bash
npm install -g opencode-ai
```

```bash
brew install anomalyco/tap/opencode
```

Verify it landed:

```bash
opencode --version
```

If the shell says `command not found` after the curl install, the binary went to `~/.opencode/bin`. Add it to your PATH:

```bash
echo 'export PATH="$HOME/.opencode/bin:$PATH"' >> ~/.zshrc && source ~/.zshrc
```

## Step 2: Get the free NVIDIA API key

1. Go to [build.nvidia.com](https://build.nvidia.com) and sign in (a free NVIDIA developer account, no credit card).
2. Open the [nemotron-3-ultra-550b-a55b model page](https://build.nvidia.com/nvidia/nemotron-3-ultra-550b-a55b).
3. Click **Get API Key** / **Build with this NIM**.
4. Copy the key. It starts with `nvapi-`.

Two things worth knowing:

- The key works across every model on build.nvidia.com, not just Nemotron. Same key, same base URL, different model ID.
- The endpoint is OpenAI-compatible: `https://integrate.api.nvidia.com/v1`. Anything that speaks the OpenAI chat-completions API can use it.

Sanity-check the key before you touch opencode config. This saves you debugging the wrong layer:

```bash
curl https://integrate.api.nvidia.com/v1/chat/completions -H "Authorization: Bearer $NVIDIA_API_KEY" -H "Content-Type: application/json" -d '{"model":"nvidia/nemotron-3-ultra-550b-a55b","messages":[{"role":"user","content":"say hi"}],"max_tokens":20}'
```

If that returns JSON with a message, the key is good. If it returns 401, the key is wrong. If it returns 404, the model ID is wrong.

## Step 3: Add NVIDIA as an opencode provider

opencode does not ship an NVIDIA provider by default, so you add it as a generic OpenAI-compatible provider. Two files.

**Config**, at `~/.config/opencode/opencode.json`:

```json
{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "nvidia": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "NVIDIA NIM",
      "options": {
        "baseURL": "https://integrate.api.nvidia.com/v1"
      },
      "models": {
        "nvidia/nemotron-3-ultra-550b-a55b": {
          "name": "Nemotron 3 Ultra 550B",
          "limit": {
            "context": 1000000,
            "output": 32768
          }
        }
      }
    }
  }
}
```

**Credentials**, at `~/.local/share/opencode/auth.json`:

```json
{
  "nvidia": {
    "type": "api",
    "key": "nvapi-YOUR_KEY_HERE"
  }
}
```

Keeping the key in `auth.json` instead of `opencode.json` is deliberate: the config file is the one you might commit to a dotfiles repo, and the auth file is the one you never do.

The provider key (`nvidia`) must be **identical** in both files. That mismatch is the single most common setup failure.

### Optional: reasoning budget

Nemotron 3 Ultra supports inference-time reasoning control. If you want it thinking harder, or cheaper and faster, pass it through `extraBody`, and raise the timeout, because long reasoning turns will blow past opencode's default:

```json
"models": {
  "nvidia/nemotron-3-ultra-550b-a55b": {
    "name": "Nemotron 3 Ultra 550B",
    "options": {
      "timeout": 600000,
      "extraBody": {
        "chat_template_kwargs": {
          "thinking": true,
          "reasoning_budget": 512
        }
      }
    },
    "limit": { "context": 1000000, "output": 32768 }
  }
}
```

Lower `reasoning_budget` for speed on simple edits; raise it for hard debugging. This is the knob that most changes the feel of the model.

## Step 4: Select the model and run

```bash
cd ~/your-project
opencode
```

Inside the TUI:

```
/init
```

`/init` reads your repo and writes an `AGENTS.md`, the project brief the agent reads on every session. Do not skip it. An agent with no project conventions will invent them.

Then pick the model:

```
/model
```

Type `nemotron` to filter, hit enter. Or set it directly:

```
/model nvidia/nvidia/nemotron-3-ultra-550b-a55b
```

The doubled `nvidia/nvidia/` is not a typo. The first segment is your provider key from `opencode.json`, the second is part of NVIDIA's model ID.

Want it to be the default so you never pick again? Add to `opencode.json`:

```json
"model": "nvidia/nvidia/nemotron-3-ultra-550b-a55b"
```

Now give it real work:

```
Read AGENTS.md, then add a /health endpoint that returns build SHA and uptime. Follow the existing route conventions.
```

## Troubleshooting

| Symptom | Cause | Fix |
| --- | --- | --- |
| `Provider not found` | Key mismatch between `opencode.json` and `auth.json` | Both must say `nvidia` |
| 401 Unauthorized | Bad or expired key | Regenerate at build.nvidia.com; confirm the `nvapi-` prefix |
| 404 model not found | Wrong model ID | It is `nvidia/nemotron-3-ultra-550b-a55b`, lowercase |
| Hangs on "Thinking" forever | Long reasoning turn exceeding the default timeout | Set `"timeout": 600000` and lower `reasoning_budget` |
| Model not in `/model` list | Config not reloaded, or invalid JSON | Fully quit and relaunch opencode; run the file through `jq .` |
| 429 rate limited | Free tier throttle | Wait, or fall back to a second provider |
| Tool calls loop or stall mid-task | The known weak column: agentic tool use | Break the task into smaller explicit steps |

That last row is not a bug you can configure away. It is the benchmark showing up in your terminal. Smaller, more explicit prompts are the workaround.

## Free tier reality check

NVIDIA's NIM tier is free and requires no credit card. What NVIDIA does **not** clearly publish is the exact RPM/RPD limits or firm commercial terms, so treat it as a generous developer tier, not a production SLA. Check the current terms before you ship a product on it.

If you want a documented number for comparison, [OpenRouter's free tier](https://openrouter.ai/nvidia/nemotron-3-ultra-550b-a55b:free) for the same model publishes 20 requests/minute and 200 requests/day. That is a reasonable mental model for what "free tier" means here: fine for a solo developer working a normal day, not fine for a CI pipeline hammering it.

Since the weights are open, the third option always exists: self-host. Realistically that means 8x H100 or 4x B200, so for most people, the free API is the answer.

## What I would actually do with this

A stack that costs nothing changes what you're willing to try. The specific wins:

1. **Learning and side projects.** Unlimited experimentation with zero billing anxiety is the entire point.
2. **Large-codebase Q&A.** The 1M context and the RULER score are the strongest real claim here. Point it at a repo you did not write and ask it questions.
3. **A second opinion.** Run the same bug past a different model family. Disagreement between two models is a genuinely useful signal.
4. **Bulk mechanical work.** Test backfills, docstrings, type annotations: high volume, low ambiguity, exactly the shape it handles well.

Where I would still reach for a paid frontier model: unattended multi-file refactors and anything where a wrong tool call costs an hour.

And the part that does not change with the model: the agent is only as good as the context you hand it. `AGENTS.md`, scoped rules, and a review step matter more than which weights are behind the API. That is the same argument as [Cursor vs Claude Code](/blog/cursor-vs-claude-code): pick by job, and keep the project's brain in files on disk.

## Sources

- [NVIDIA Nemotron 3 Ultra research page](https://research.nvidia.com/labs/nemotron/Nemotron-3-Ultra/)
- [NVIDIA technical blog: Nemotron 3 Ultra for long-running agents](https://developer.nvidia.com/blog/nvidia-nemotron-3-ultra-powers-faster-more-efficient-reasoning-for-long-running-agents/)
- [build.nvidia.com model page](https://build.nvidia.com/nvidia/nemotron-3-ultra-550b-a55b)
- [Hugging Face weights](https://huggingface.co/nvidia/NVIDIA-Nemotron-3-Ultra-550B-A55B-BF16)
- [BenchLM independent benchmark aggregation](https://benchlm.ai/models/nemotron-3-ultra)
- [OpenRouter free tier listing](https://openrouter.ai/nvidia/nemotron-3-ultra-550b-a55b:free)
- [opencode docs](https://opencode.ai/docs/)


## Related
- [kit-picker](https://www.agentickit.co/tools/kit-picker)
- [tech-lead](https://www.agentickit.co/agents/tech-lead)
- [code-reviewer](https://www.agentickit.co/agents/code-reviewer)
- [project-conventions](https://www.agentickit.co/skills/project-conventions)
- [prompt-engineering](https://www.agentickit.co/skills/prompt-engineering)
- [/ship](https://www.agentickit.co/commands/ship)
- [/fix](https://www.agentickit.co/commands/fix)
