Cloud-based AI coding assistants are great — until you hit a usage cap, worry about sending your code to someone else’s server, or just don’t have Wi-Fi on a flight. What if your coding agent lived entirely on your machine instead?

In this guide, I’ll walk you through setting up a completely local AI coding agent using three free tools:

• Ollama — runs AI models locally on your machine

• Qwen3:8B — a lightweight but surprisingly capable open-source model

• OpenCode — an AI coding agent that plugs straight into your terminal and VS Code

No API keys. No cloud bills. No internet required once it’s set up. I tested this whole stack on a mid-range laptop (16GB RAM, 8GB VRAM, RTX 3070), so if your machine can run a modern game, it can probably run this too.

Let’s get into it.

What You’ll Need

• A laptop or desktop with at least 8GB of VRAM (or a decent amount of unified/system RAM if you’re on Apple Silicon)

• Node.js installed (for OpenCode)

• About 10–15 minutes and a few GB of free disk space

💡 Picking a model for your hardware: Qwen3:8B is a solid middle-ground choice — small enough to run smoothly on 8GB of VRAM, but sharp enough to handle real coding tasks. If you’ve got a beefier GPU (16GB+ VRAM), you could size up to a larger Qwen3 variant for better results. If you’re on a lighter laptop, Ollama also has smaller models (like 3B–4B parameter ones) that’ll run more comfortably.

Step 1: Install Ollama

Ollama is the engine that runs the AI model on your machine — think of it as the “server” your coding agent will talk to.

1. Head to ollama.com and download the installer for your OS (Windows, macOS, or Linux).

2. Run the installer like any other app.

Once it’s installed, Ollama runs quietly in the background and exposes a local API at:

http://localhost:11434

![alt text](https://aravinda89.github.io/images/Screenshot 2026-09-11 111426.png align="center")

You won’t need to touch this URL directly — just know it’s there, because we’ll point OpenCode at it later.

Step 2: Download the Qwen3:8B Model

With Ollama installed, open your terminal and pull the model:

ollama pull qwen3:8b

This downloads the model’s weights to your machine (a few gigabytes, so grab a coffee ☕). You’ll see a progress bar as it downloads:

Once it’s done, you’ll see a confirmation that the model is ready to use. That’s it — you now have a full AI model running locally, with zero cloud dependency.

Step 3: Install OpenCode

OpenCode is the actual “agent” — the tool that reads your code, understands your prompts, and makes edits, all from your terminal or VS Code.

Install it globally via npm:

npm install -g opencode-ai

Step 4: Point OpenCode at Ollama

Now we need to tell OpenCode “hey, don’t call OpenAI or Anthropic — talk to the model running on my own machine instead.” This is done through a config file.

1. Create (or open) the opencode.json config file at:

   • Windows: C:\Users\<YourUsername>\.config\opencode\opencode.json

   • macOS/Linux: ~/.config/opencode/opencode.json

2. Paste in the following config (also available as a gist here):

{
  "$schema": "https://opencode.ai/config.json",
  "model": "ollama/qwen3:8b",
  "provider": {
    "ollama": {
      "npm": "ollama-ai-provider-v2",
      "name": "Ollama (Local)",
      "options": {
        "baseURL": "http://localhost:11434/api"
      },
      "models": {
        "qwen3:8b": {
          "name": "Qwen3 8B (local)",
          "tool_call": true,
          "limit": { "context": 16384, "output": 4096 }
        }
      }
    }
  }
}

A quick breakdown of what matters here:

• baseURL — points OpenCode to Ollama’s local API instead of a cloud provider

• tool_call: true — enables the agent to actually run tools/commands, not just chat

• limit.context — how much text the model can “remember” in a single session (adjust down if you’re low on VRAM)

Step 5: Fire It Up Inside VS Code

1. Open your project folder in VS Code.

2. Open the built-in terminal (Ctrl or Cmd+).

3. Type:

opencode

1. Inside OpenCode, run /models and select Qwen3 8B from the list.

Step 6: Test Your Local Coding Agent

Give it a small task — ask it to explain a function, write a test, or refactor a snippet. If it responds and starts editing files, congratulations: you now have a private, offline, zero-subscription AI coding agent running entirely on your own hardware.

Troubleshooting Tips

• OpenCode can’t connect to the model? Make sure Ollama is actually running in the background (ollama list should show qwen3:8b).

• Responses feel slow? That’s normal for local inference on consumer hardware — try a smaller model if speed matters more than capability.

• Out of memory errors? Lower the context limit in your config, or switch to a smaller model like a 3B or 4B parameter variant.

Why Bother Going Local?

• Privacy — your code never leaves your machine

• No usage limits or subscriptions — it’s yours, forever, for free

• Works offline — perfect for flights, coffee shops with bad Wi-Fi, or secure environments

• Great for learning — you get hands-on with how these agent tools actually work under the hood

Frequently Asked Questions

Do I need a powerful GPU to run this? No — Qwen3:8B runs comfortably on 8GB of VRAM. Lighter models are available if your hardware is more modest.

Can I use a different model instead of Qwen3:8B? Yes. Any model available through Ollama can be swapped in — just update the model field in your opencode.json and pull it with ollama pull <model-name>.

Is OpenCode free? Yes, OpenCode is free and open-source, and pairing it with Ollama means the entire stack costs nothing to run.

That’s the whole setup — a private, local AI coding agent with no cloud, no API keys, and no bill at the end of the month. If you try this out, I’d love to hear which model worked best on your hardware.

Written on September 11, 2026

There’s a third option, and it costs nothing: run the whole thing on your own computer. No subscription. No internet. Your code never leaves your machine.

I set this up on a fairly ordinary PC, and it works. Here’s exactly how.

What you’re building

Three pieces working together:

• LM Studio — runs the AI model on your PC. This is the engine.

• opencode — the coding assistant that reads and edits your files.

• VS Code — where you actually write code.

LM Studio does the thinking. opencode does the work. VS Code is where you sit.

My setup: Windows, RTX 3070 Ti with 8GB VRAM, 16GB RAM. That’s a mid-range gaming PC, not a workstation. If yours is similar, you’re fine.

Step 1: Install LM Studio

Download it from lmstudio.ai and install it like any normal app.

LM Studio lets you download and run open-source AI models directly on your computer. It’s the easiest way into local AI — no command line required.

Press enter or click to view image in full size

Step 2: Download the model

Open the search inside LM Studio and look for qwen3 8b.

You’ll see a lot of versions. Check these three things before you download:

Why those matter, in plain English:

Quantization is compression. Q4_K_M shrinks the model so it fits on a smaller graphics card. You lose a little quality, but you gain the ability to actually run it.

Tool use is non-negotiable. A coding assistant needs to open your files and edit them. A model without tool use can only chat about your code — it can’t touch it. Skip this check and nothing will work later.

Press enter or click to view image in full size

Got different hardware? Pick a model that fits it. Bigger models are smarter but hungrier. An 8B model is a comfortable fit for 8GB of VRAM.

Once the download finishes, your model shows up under My Models.

Press enter or click to view image in full size

Step 3: Load the model

Go to the Developer tab and select your model.

Turn on “Manually choose model load parameters”, then click the small arrow next to the model name to open the settings.

Press enter or click to view image in full size

Now find context size and set it to 16000.

Context size is how much text the model can hold in its head at once — your question plus its answer plus whatever code it’s looking at. Bigger context means it understands more of your project. It also eats more VRAM.

16000 is a good number for 8GB. If you have less, go lower. If the model refuses to load, lower it again and try once more.

Press enter or click to view image in full size

Step 4: Turn on the server

Flip the server status to Running.

Press enter or click to view image in full size

Your model is now live at http://127.0.0.1:1234.

That address is your own machine talking to itself. Nothing is going out to the internet — which is the entire point.

Step 5: Install VS Code and opencode

Install VS Code if you don’t have it.

Then install opencode. On Windows in command prompt, the simplest route is npm:

Open a terminal inside VS Code ( Terminal → New Terminal) and type:

opencode starts up right there in the terminal panel.

Press enter or click to view image in full size

Step 6: Point opencode at your local model

Here’s the part that trips people up. opencode has no idea your model exists yet. You have to tell it, using a config file.

Create the config file — here’s mine

save it to:

Swap YOUR_USERNAME for your actual Windows username. If that folder doesn't exist, create it.

Step 7: Pick your model and test it

Restart VS Code, then start opencode again.

Type /models and select qwen/qwen3-8b from the list.

Press enter or click to view image in full size

Now ask it to do something real. Give it a file to fix.

Press enter or click to view image in full size

Want proof it’s actually running locally? Switch over to LM Studio and check the logs. You’ll see tokens streaming as the assistant types.

Press enter or click to view image in full size

That’s your own GPU doing the work.

What to expect

Let’s be straight about this: a local 8B model is not going to match Claude or GPT on a hard architectural problem. It’s smaller, and smaller means less capable.

But for the everyday stuff — writing boilerplate, explaining unfamiliar code, catching bugs, renaming things across files — it holds its own. And it’s fast, because there’s no network round trip.

The best part is what it costs: nothing, forever. No token limits. No monthly bill. Works on a plane.

If you have more VRAM than I do, try a larger model. Same steps, better results.

Originally published at https://aravinda89.github.io on September 5, 2026.