Your Coding Agent Doesn't Care Which Model Runs It

NVIDIA shipped a free open model strong enough to plan, write, test, and fix code on its own. This guide gets it wired into your terminal in about fifteen minutes, with two connection paths and no credit card. The one you should copy first is Path A.

Paid coding assistants used to be the only serious option. That stopped being true when NVIDIA released Nemotron 3 Ultra, the biggest open model it has published so far.

The agent that runs the model is a separate thing from the model itself. That gap is where the money leaks out of most businesses. You are renting a flagship model for work a free one would finish just as well.

So here is the whole method before any setup. Install a terminal agent. Point it at a free model. Give it one real task. Watch it plan, write, and fix on its own. Then keep the setup and swap the engine whenever a cheaper or stronger one shows up.

What Nemotron 3 Ultra Actually Is

Nemotron 3 Ultra is an open agentic model built for long jobs, not one-line answers. The weights are public under an open license, so nobody owns your access to it.

Here is what the specs mean once it is doing your work.

One honest note on the 5x. That is a throughput number NVIDIA published against other open models of the same size. It is not a promise that every job finishes five times sooner. Real speed depends on the host and the prompt. Treat it as clearly fast, not a stopwatch.

What Is A Coding Agent, And Why Does A Free Model Cut The Bill

A coding agent is the program that does the work. It reads your request, breaks it into steps, writes files, runs them, checks the result, and fixes what broke. The model is the reasoning it borrows to do all of that. Two separate parts. You can change one without touching the other.

That split is the whole point, and it is where most businesses overpay. People pick one paid model and route every job through it, including the plain ones. Renaming a folder of files. Reformatting a spreadsheet. Turning a call note into three bullet points. None of that needs frontier-grade reasoning. It needs an agent that finishes the loop, and a competent model behind it.

Nemotron 3 Ultra is a competent model that costs nothing. For the bulk of day-to-day operations work, it clears the bar. A small share of genuinely hard jobs may still be worth a paid model, and you keep that option open for those. What you stop doing is paying flagship rates for filing and formatting.

Think of the model as a part you can swap, like the engine in a car you already know how to drive. Once the agent and your tasks are set, the model behind them is a line in a config file. Better one ships next month, you change the line. Your workflow does not notice.

Step One: Install opencode In One Command

opencode is the terminal agent that drives the model. It plans and runs the work. Nemotron is only the brain behind it.

Copy this into your terminal:

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

Prefer a package manager? Any of these installs it too.

Then move into the project folder you want to work in and launch it:

opencode

Done. The agent is installed and running.

The mistake that makes this fail: the npm package is named opencode-ai, not opencode. Type npm install -g opencode and you get the wrong package or an error. The extra -ai is the whole fix.

Step Two: Connect A Free API (2 Paths)

Two ways in. Path A is faster and matches what most people want. Path B gives you your own NVIDIA key and a config file you control. Read both, pick one.

Path A: opencode's Built-In Free Tier

This is the fast lane. No config file, no card.

Inside opencode, run /connect. Pick opencode from the provider list, shown as the "Zen" menu. Follow the sign-in prompt, copy the API key it hands you, and paste it back into the terminal.

That is the entire path. Skip ahead to Step Three.

Path B: Your Own Free NVIDIA Key

This path takes a few more minutes and gives you a key that is yours. Go to build.nvidia.com and create a free developer account. No credit card. Open Settings, then API Keys, and generate one. It starts with nvapi-.

The endpoint speaks the same language as most tools, and the free tier runs at roughly forty requests per minute. Use these values:

Export the key, then register NVIDIA as a custom provider in your opencode.json config.

export NVIDIA_API_KEY="nvapi-your-key-here"

{
    "$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 (Free)",
            "limit": { "context": 1000000, "output": 65536 }
          }
        }
      }
    }
}

Save it, then restart opencode so it loads the new provider. The restart is not optional. Skip it and the next step will look broken for no reason.

Step Three: Point opencode At The Model

Open the model switcher inside opencode. Search for Nemotron 3 Ultra. Select the free version. On Path B it sits under the NVIDIA NIM provider you just added.

Done. opencode is now running on a free model.

The mistake that makes this fail: on Path B, a missing model almost always means one of two things. You did not restart opencode after saving the config, or the model key in your config does not match the API's model ID. It has to read nvidia/nemotron-3-ultra-550b-a55b, character for character. One wrong letter and it will not show up.

Your First Real Run

Give it one real task and watch the full loop run. This is the exact kind of prompt from the demo. Paste it in:

Build a premium scroll-driven landing page. Light theme, with a glossy
3D object that glides across every section as the user scrolls.

It plans the page first. Then it writes the code. Then it tests and fixes the code on its own. A few minutes later you have a working page with the 3D shape moving across every section as you scroll.

Now swap that prompt for something from your own week. A script that renames and files last month's invoices. A small internal page that shows this week's bookings. A tool that turns a folder of call notes into a clean summary. Same loop, your work instead of a demo.

The mistake that makes your first build disappoint: a prompt that is too big and too vague. "Build me a CRM" gives the agent nowhere solid to stand, so it guesses, and you spend the next hour correcting guesses. "Build a page that lists this week's bookings from this CSV, newest first" gives it a target it can actually hit. Start narrow. Get one real thing working. Then grow it in the next message, one clear step at a time.

Path A Or Path B: Which To Pick

If you are confused about which connection path to run, this is the whole decision.

Start on Path A. Move to Path B the day you want the key under your own account. The rest of your setup does not change when you switch.

Honest: What To Know Before You Lean On It

This is free and open, and it is also worth knowing where the edges are before you put real work through it.

The free tier has a rate limit, around forty requests per minute. That is plenty for one person working through tasks. A heavy agent loop firing constantly may pause and retry, so this is fine for a solo operator and not yet the engine for a busy team pipeline.

The model's reasoning is hidden by default. It thinks before it answers, but most setups keep that thinking off-screen, so you see the result and not the working. That is normal. It is not stuck.

It is a real agent, not autocomplete. Hand it a goal and let the plan, write, test, and fix loop run. Small, clear tasks land best. A vague one-liner gets you a vague result, same as with any model.

And when the output is wrong, say so plainly in the next message. Type something like: the filename logic is off, files with spaces get skipped, fix that. It re-plans and corrects. You are steering, not starting over.

There is no lock-in anywhere in this. The weights are open. If the free host ever changes its terms, you point the same opencode setup at another host, or run the weights yourself. Your workflow does not move.

The Part That Actually Matters

The model is not the moat. Your agent runs the same loop whether a paid model or a free open one sits behind it. Most of the work your agents do, the renaming and filing and summarizing and drafting, does not need a flagship. A small share of hard jobs might, and for those you keep the option open.

So build the workflow once. Get the setup solid, get the tasks defined, get it doing real work. Then treat the model as a part you can replace, because a better or cheaper one lands every few weeks now.

If you do one thing this week, install opencode and run the landing-page prompt once. Fifteen minutes, start to finish. If it does not earn a place in your week, you spent fifteen minutes and learned exactly what these agents can and cannot do yet. That is a fair trade either way.