Free Coding Agent with NVIDIA Nemotron: Self-Host on a Cheap VPS

Two free things stacked on top of one cheap thing.

• NVIDIA Nemotron 3 Super 120B-a12b. A 120B hybrid Mamba/Transformer MoE that activates 12B parameters per token. 1M context window. Released March 2026 under NVIDIA's open license. Free tier on build.nvidia.com with rate limits in the ~40 RPM range, no per-token cost. The same model is also mirrored as a free tier on OpenRouter if you prefer to go through them.
• OpenCode. Open-source coding agent, TUI plus IDE extensions, client/server architecture so you can run the server on the VPS and connect from your laptop or phone. Works with any OpenAI-compatible endpoint.
• A $4 to $7 VPS. 2 vCPU and 4 GB RAM is plenty. The agent process is light. Inference is remote.

Why not just use the SaaS in the original post?

• Lock-in. Your prompts, history, repos, and connectors live in a third party. If they pivot or raise prices, you migrate.
• Cost path. Free tiers on hosted agent SaaS tend to shrink once usage picks up. The model being free does not mean the wrapper stays free.
• Privacy. A self-hosted agent on your VPS sees your code on disk. Inference still leaves the box to NVIDIA, but the rest of the pipeline is yours.
• It is not harder. This whole setup is fewer steps than the SaaS flow once you have an SSH key.

All four of these run the agent comfortably. Prices as of May 2026.

For a single-tenant coding agent, Hetzner CX22 is what I would default to. If you want more headroom to run side projects on the same box, Contabo VPS S gives you double the RAM for a couple of dollars more, with the caveat that the vCPUs are shared and noisier under load.

The rest of this guide uses Ubuntu 24.04 commands, but they map cleanly to any of the four.

1. Sign in at build.nvidia.com. A regular NVIDIA developer account is fine.
2. Open build.nvidia.com/settings/api-keys and generate a key. It is prefixed nvapi-.
3. Find the Nemotron 3 Super 120B-a12b entry and confirm the model ID. At time of writing it is nvidia/nemotron-3-super-120b-a12b. NVIDIA occasionally renames variants, so always read the page rather than copy-pasting from a tutorial.

The endpoint is https://integrate.api.nvidia.com/v1. It speaks the standard OpenAI chat-completions protocol.

A quick smoke test from your laptop, before touching the VPS:

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-super-120b-a12b",
    "messages": [{"role": "user", "content": "Reply with a single word: ready"}]
  }'

If that returns a JSON response with ready in the content, the key works.

Pick a provider, deploy Ubuntu 24.04, paste your SSH public key during creation, and grab the public IP.

ssh root@YOUR-VPS-IP
apt update && apt upgrade -y
apt install -y curl git ufw

Make a non-root user and put SSH and the firewall in a reasonable shape.

adduser agent --disabled-password --gecos ""
usermod -aG sudo agent
echo "agent ALL=(ALL) NOPASSWD:ALL" > /etc/sudoers.d/agent
chmod 440 /etc/sudoers.d/agent

mkdir -p /home/agent/.ssh
cp ~/.ssh/authorized_keys /home/agent/.ssh/ 2>/dev/null || true
chown -R agent:agent /home/agent/.ssh
chmod 700 /home/agent/.ssh
chmod 600 /home/agent/.ssh/authorized_keys

sudo ufw default deny incoming
sudo ufw default allow outgoing
sudo ufw allow ssh
sudo ufw enable

Switch over and stay on the agent account from here on.

su - agent

OpenCode ships a single-binary installer.

curl -fsSL https://opencode.ai/install | bash
source ~/.bashrc
opencode --version

If you would rather run it under Node, npm i -g opencode-ai works too. Either way, confirm it is on PATH before continuing.

OpenCode reads provider config from ~/.config/opencode/opencode.json. Create it with a custom OpenAI-compatible provider entry:

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "nv": {
      "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-super-120b-a12b": {
          "name": "Nemotron 3 Super 120B"
        }
      }
    }
  },
  "model": "nv/nvidia/nemotron-3-super-120b-a12b"
}

Export the key so OpenCode can read it. Drop it into ~/.bashrc so it survives reboots.

echo 'export NVIDIA_API_KEY="nvapi-your-key-here"' >> ~/.bashrc
source ~/.bashrc
chmod 600 ~/.config/opencode/opencode.json

Start it and confirm the model is selected.

mkdir -p ~/projects && cd ~/projects
opencode

Inside the TUI, the model picker should list NVIDIA NIM › Nemotron 3 Super 120B. Pick it, ask it to write a small file, and confirm it actually performs the action. If it errors out on the call, the message is almost always a bad key or a wrong model ID.

The point of putting this on a VPS is so you do not have to keep an SSH session open. A user-level systemd unit handles that.

Put the API key in a dedicated env file so it never lands in a world-readable unit file or journal line.

mkdir -p ~/.config/opencode
echo 'NVIDIA_API_KEY=nvapi-your-key-here' > ~/.config/opencode/opencode.env
chmod 600 ~/.config/opencode/opencode.env

[Unit]
Description=OpenCode agent server
After=network.target

[Service]
Type=simple
WorkingDirectory=/home/agent/projects
EnvironmentFile=%h/.config/opencode/opencode.env
ExecStart=/home/agent/.local/bin/opencode serve --port 4096 --hostname 127.0.0.1
Restart=on-failure

[Install]
WantedBy=default.target

Enable it and tail the logs.

chmod 600 ~/.config/systemd/user/opencode.service
systemctl --user daemon-reload
systemctl --user enable --now opencode
journalctl --user -u opencode -f

The server now listens on 127.0.0.1:4096. Do not open that port in ufw. To reach it from your laptop, use SSH port-forwarding.

ssh -L 4096:127.0.0.1:4096 agent@YOUR-VPS-IP

Now http://localhost:4096 on your laptop is the agent on the VPS. The OpenCode desktop app and IDE extensions both accept a remote server URL. Point them at that and they will drive the remote agent.