Nemotron 3 Ultra Free with OpenCode: Setup + Real Test vs Claude

Run NVIDIA Nemotron 3 Ultra free in OpenCode: two free endpoints, 5-step setup, and an honest comparison with Claude Sonnet 5 (71.9% vs 85.2% SWE-bench Verified).

Disclosure: this article has no affiliate links. Nemotron 3 Ultra, OpenCode and the free endpoints covered here are free to try. Sophrai is not affiliated with NVIDIA, OpenRouter, OpenCode or Anthropic. Read our affiliate disclosure.

Short answer: you can run NVIDIA Nemotron 3 Ultra for free inside OpenCode, the open-source terminal coding agent, in about five minutes. There are two free routes: NVIDIA’s own hosted endpoint on build.nvidia.com, or OpenRouter’s :free variant with a 1M-token context window. On NVIDIA’s model card it scores 71.9% on SWE-bench Verified. Claude Sonnet 5 scores 85.2% on Anthropic’s numbers. So it’s a strong free model for prototyping, refactors and long-context work, but it isn’t a like-for-like Claude replacement for hard production coding. The catch: the free tiers are rate-limited and NVIDIA’s endpoint is for development and testing only. All numbers below come from NVIDIA, OpenRouter and Anthropic pages, checked on 31 October 2026.

Watch the setup and test walkthrough

More AI agent and automation breakdowns on our YouTube channel: sophraiAI on YouTube.

What is Nemotron 3 Ultra?

Nemotron 3 Ultra is NVIDIA’s largest open model, released on 4 June 2026. It is a Mixture-of-Experts (MoE) model with 550B total parameters and 55B active per token, built on a hybrid Mamba-Transformer design (NVIDIA calls the expert layer “LatentMoE”) with multi-token prediction for faster generation. It supports up to 1M tokens of context, reasons before it answers (thinking can be switched on or off), and is tuned for long-running agents that plan, call tools and recover from errors.

For business teams, three things matter more than the architecture. First, it’s open: weights, much of the training data and recipes are on Hugging Face under the OpenMDW-1.1 license, so you can self-host it later if the free tiers aren’t enough. Second, NVIDIA trained it to behave consistently across agent harnesses, OpenCode included. Third, it can be used for free today.

SpecNemotron 3 UltraSource
Release date4 June 2026NVIDIA model card, Hugging Face
Parameters550B total, 55B active (MoE)NVIDIA technical report, Hugging Face
Context windowUp to 1M tokensNVIDIA model card
ReasoningOn/off via chat template, adjustable budgetHugging Face model card
LicenseOpenMDW-1.1 (open weights)Hugging Face model card
Hosted model IDnvidia/nemotron-3-ultra-550b-a55bbuild.nvidia.com, OpenRouter

The free options: NVIDIA endpoint vs OpenRouter :free

“Free” means two different things here, and the limits are different. Pick based on how many requests your test needs.

NVIDIA build.nvidia.comOpenRouter :free
Model IDnvidia/nemotron-3-ultra-550b-a55bnvidia/nemotron-3-ultra-550b-a55b:free
CostFree with an NVIDIA Developer Program account$0 per token
Context1M (model limit)1M tokens, up to 65,536 output tokens
Rate limitsSet per model and shown in your account; NVIDIA says they vary with load. No published daily cap.20 requests/min and 50 requests/day; 1,000/day once you have bought at least $10 of credits
Allowed usePrototyping, research, development and testing only, not productionFree-variant limits apply; prompts may be logged by free providers, so check the model page
Get a keybuild.nvidia.com, then Get API Key (starts with nvapi-)openrouter.ai, then Create API Key

Our pick: use NVIDIA’s endpoint for a first test, because it has no published daily cap. Switch to OpenRouter if you already use it for other models, and buy $10 of credits if 50 requests a day is too tight. An agent session can easily make 30–50 model calls on one task. If you need it in production, use a paid provider (OpenRouter’s paid variant lists $0.60 input / $2.40 output per million tokens) or self-host.

How to set up Nemotron 3 Ultra in OpenCode (free)

Step 1: Install OpenCode

Pick one method. You need Node.js for npm, or macOS/Linux/WSL for the install script.

npm install -g opencode-ai
# or
curl -fsSL https://opencode.ai/install | bash

opencode --version

Step 2: Get a free API key

NVIDIA route: sign in at build.nvidia.com, open the Nemotron 3 Ultra page, click Get API Key and copy the nvapi- key. OpenRouter route: create a key at openrouter.ai. Treat both keys like passwords: never paste them into a repo, a prompt or a screenshot.

Step 3: Connect the provider in OpenCode

Open your project folder and start OpenCode, then run /connect, search for NVIDIA (or OpenRouter) and paste the key. OpenCode stores it in ~/.local/share/opencode/auth.json, outside your project. You can also set it as an environment variable instead:

cd ~/your-project
export NVIDIA_API_KEY="nvapi-..."   # NVIDIA route
opencode

# inside OpenCode:
/connect

Step 4: Pick the model

Run /models and choose nvidia/nemotron-3-ultra-550b-a55b (NVIDIA) or nvidia/nemotron-3-ultra-550b-a55b:free (OpenRouter). If the model doesn’t appear in the NVIDIA list, add it in ~/.config/opencode/opencode.json. This is based on NVIDIA’s own OpenCode cookbook, with the key read from the environment rather than typed into the file:

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

Step 5: Initialise and give it a real task

Run /init so OpenCode reads the repo and writes an AGENTS.md file with the project context. Then start with a small, checkable task, such as “add input validation to the signup form and write tests”. Use OpenCode’s plan agent first if you want to review the approach before it edits files.

Quick sanity check (optional)

If OpenCode errors out, test the key outside the agent first. A JSON reply means the key and model ID are right; a 401 means a bad key; a 404 means a wrong model ID.

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}'

Nemotron 3 Ultra vs Claude: the honest comparison

The fairest public number for coding agents is SWE-bench Verified: real GitHub issues that the agent must fix so the project’s tests pass. Here is what each vendor reports. Different harnesses produce different scores, so treat a gap of a few points as noise, but a gap of 13 points as real.

Nemotron 3 UltraClaude Sonnet 5
SWE-bench Verified (vendor-reported)71.9% (BF16) / 69.7% (NVFP4), NVIDIA model card85.2%, Anthropic
SWE-bench Verified across agent tools65%–70.4% across Pi, OpenHands, Hermes, OpenCode and Mini SWE Agent (NVIDIA blog)Not published per harness
Context window1M tokens1M tokens
Price via APIFree tiers (rate-limited); paid on OpenRouter from $0.60 / $2.40 per M tokens$2 input / $10 output per M tokens (Anthropic pricing)
WeightsOpen (OpenMDW-1.1), self-hostableClosed
Best fitPrototypes, refactors, long-context reading, cost-sensitive agentsHard bugs, large multi-file changes, production code

What the numbers mean in practice. On 100 real issues, the vendors’ own numbers suggest Claude Sonnet 5 fixes about 85 and Nemotron 3 Ultra about 66–72, depending on the harness. That is a clear gap on hard tasks. On routine work (CRUD endpoints, tests, small refactors, config files, scripts), both usually get there, and Nemotron does it at $0 within the free limits. NVIDIA also reports that Ultra uses fewer tokens per task than comparable open models, which it says cuts agent cost by up to 30%.

Note that Anthropic has since released Claude Sonnet 5.5 at the same $2 / $10 price, so the gap at the top end is unlikely to shrink. We compare against Sonnet 5 because that’s the model with a published SWE-bench Verified score.

How to run your own real test in 30 minutes

Benchmarks don’t know your codebase. Before you switch a team’s workflow, run the same three tasks on both models in the same OpenCode project, from a clean Git branch each time:

  1. Small fix: a real bug from your tracker with a failing test. Score it on whether the tests pass and how many turns it took.
  2. Feature: one endpoint or component plus tests. Score it on whether it runs, is readable, and needed manual fixes.
  3. Long-context read: “explain how auth works across this repo and list risks”. Score it on accuracy and missed files.
  4. Log the cost side: wall-clock time, number of requests (this matters for the 50/day free cap) and any rate-limit errors.
  5. Decide by task type, not overall. Many teams end up with a free model for routine work and Claude for the hard 20%.

Limitations to know before you rely on it

  • Free isn’t for production. NVIDIA’s hosted API is a trial for prototyping and testing. For production you need a paid provider, NVIDIA AI Enterprise or your own hardware.
  • Rate limits bite agents. One agent task can make dozens of calls. OpenRouter’s 50 requests/day free cap can run out in one session; NVIDIA’s limits vary with load and can slow long runs.
  • Weaker on hard coding than Claude. 71.9% vs 85.2% on SWE-bench Verified is a real gap on difficult multi-file bugs.
  • Benchmark numbers vary by source. NVIDIA’s model card says 71.9%, its Hugging Face README and technical report chart say 70.7%, and its blog gives 65%–70.4% across agent tools. Use the range, not the best number.
  • Reasoning costs time. Thinking mode produces long reasoning traces. Raise OpenCode’s timeout for big tasks, or lower the reasoning budget for quick edits.
  • Data handling. Free endpoints aren’t the place for client secrets or regulated data. Check each provider’s data policy before you send private code.
  • Self-hosting is heavy. The weights are open, but a 550B-parameter model needs a multi-GPU server. That only pays off at real volume.

Watch the 60-second version

Verdict: should your team use Nemotron 3 Ultra with OpenCode?

Yes, as your free second model. It costs nothing to try, it runs in a good open-source agent, it handles 1M tokens of context and it scores around 70% on SWE-bench Verified. That’s enough for prototypes, internal tools, tests, refactors and “read this whole repo” questions. Keep Claude for hard bugs, large changes and anything that ships to customers, where the extra ~13–15 points show up as fewer broken builds.

The real win is routing: send routine work to a free or cheap model and only pay for the hard tasks. That’s also how we build AI automations for clients. The model is a component, and the workflow around it decides what it costs and how reliable it is.

FAQ

Is Nemotron 3 Ultra really free?

Yes, within limits. NVIDIA offers a free hosted endpoint on build.nvidia.com for prototyping and testing, with per-model rate limits shown in your account. OpenRouter offers a :free variant with 20 requests per minute and 50 per day, rising to 1,000 per day after you buy at least $10 of credits. Neither free option is meant for production.

How do I use Nemotron 3 Ultra in OpenCode?

Install OpenCode with npm install -g opencode-ai, get a free key from build.nvidia.com or OpenRouter, run /connect in OpenCode and paste the key, then pick nvidia/nemotron-3-ultra-550b-a55b (or the :free variant on OpenRouter) with /models. Run /init in your project before the first task.

Is Nemotron 3 Ultra better than Claude for coding?

No, not on hard coding tasks. NVIDIA reports 71.9% on SWE-bench Verified and Anthropic reports 85.2% for Claude Sonnet 5. Nemotron 3 Ultra is a strong free option for routine coding, refactors and long-context work, while Claude stays ahead on difficult multi-file fixes.

What is the context window of Nemotron 3 Ultra?

Up to 1 million tokens. The OpenRouter free variant lists a 1M-token context with up to 65,536 output tokens.

How big is Nemotron 3 Ultra?

It is a Mixture-of-Experts model with 550 billion total parameters and 55 billion active per token, released by NVIDIA on 4 June 2026 with open weights under the OpenMDW-1.1 license.

Can I use the free endpoint for client work?

Use it to prototype and test, not to run production systems. NVIDIA’s free API access is for development and testing only, and free tiers can change. For production use a paid provider, NVIDIA AI Enterprise or a self-hosted deployment, and keep client secrets out of free endpoints.

Sources: NVIDIA model card on build.nvidia.com, Hugging Face model card, NVIDIA technical blog (4 June 2026), Nemotron 3 Ultra technical report, NVIDIA OpenCode setup cookbook, NVIDIA NIM FAQ, OpenRouter limits, OpenCode providers docs, Anthropic: Claude Sonnet 5, Anthropic pricing. All checked on 31 October 2026. Benchmark scores are vendor-reported; we did not re-run SWE-bench.

hamid7777 Avatar

Written & tested by

The Sophrai brief

One calm email when something actually matters.

New tools, real cost breakdowns and the automation news worth your time. No hype, no spam.