A useful local autonomous coding agent needs a GPU with at least 12 GB of VRAM (an RTX 3060 12GB is the practical floor in 2026), 32 GB of system RAM, a fast NVMe SSD for model weights, and a modern 8‑core CPU like a Ryzen 7 5800X or 5700X. With that combination you can host a 14B‑class coder model at q4 quantization, run agentic loops with tool use, and keep prompt latency under a second on typical inputs.
Why Codex‑on‑Windows reignited the "run it locally" question
OpenAI's Codex agent can now drive a Windows PC autonomously — opening apps, editing files, running test commands, and iterating against failing assertions until a build is green. That capability is genuinely useful, but for any engineer working on proprietary code it surfaces an obvious tension: a remote model that drives your machine has, by construction, visibility into everything it touches. Source files, environment variables, browser state, terminal history, sometimes credentials in process memory — all of that flows through the agent's tool calls and ultimately past OpenAI's API boundary.
That is why, every time Codex (or Claude Computer Use, or any frontier "computer‑use" agent) ships a new capability, traffic for "run a coding agent locally" spikes on Google Trends and Reddit. People want the workflow without the egress. The good news in 2026 is that local agentic loops are no longer the toy they were two years ago — open‑weight coders in the 7B–14B range have closed enough of the gap that you can get a real working agent on a single consumer GPU. The bad news is that the hardware floor is higher than most blog posts admit. A 6 GB GPU won't cut it. An 8 GB GPU is borderline. 12 GB — specifically, the RTX 3060 12GB — is the cheapest card with enough VRAM to host a 14B coder at q4 with usable context, which is why this build keeps showing up in self‑hosting threads from late 2024 onward.
This guide is for the engineer who has decided they want a local rig and now needs to know exactly what to buy, what they will and won't get out of it, and how it compares to a Codex subscription in dollars and tokens.
Key takeaways
- VRAM floor for a useful agentic coder: 12 GB. Below that, you're stuck on 7B models that struggle on multi‑file edits.
- An RTX 3060 12GB at ~$280–$330 used is the cheapest entry point — there is no competitive 12 GB consumer GPU for less.
- Realistic throughput on a 3060: ~22–30 tokens/sec generation on a 14B q4 coder, ~700–1100 tokens/sec prefill — slower than cloud Codex but fine for interactive editing.
- Pair it with a Ryzen 7 5800X or 5700X (8 cores), 32 GB DDR4, and a 1 TB NVMe (model weights are big and IO‑hot at load time).
- Break‑even versus a cloud Codex subscription is roughly 10–14 months of daily heavy use; lighter users should stay on cloud.
- A local agent never makes a network call for inference. That is the whole reason to do this.
What can OpenAI Codex actually do on a Windows PC now?
According to The Decoder's reporting on the late‑May 2026 capability update, Codex can now perform end‑to‑end coding sessions on Windows: it opens a project, reads files, runs the build, observes errors, edits source, re‑runs, and continues until a target test or sanity check passes. The same loop has existed in Linux container environments for over a year; the Windows piece matters because most enterprise developer machines are still Windows, and most enterprise codebases include Windows‑specific build steps, COM interop, MSVC quirks, and PowerShell scripts that don't survive translation into a Linux sandbox.
In practice, the agent is doing four things:
- Reading source via OS file APIs (not a sandboxed mirror).
- Issuing keystrokes and clicks to a real IDE or editor process.
- Spawning shells (cmd, PowerShell, sometimes WSL) to invoke build and test tools.
- Posting screenshots and intermediate text state back to the model for reasoning.
Each of those steps is a place where source‑code bytes leave your machine. For a hobbyist that's fine. For anyone working under an NDA or a regulated codebase, it is the reason they're reading this article.
Why would you run an agent locally instead of in the cloud?
Three reasons keep coming up in self‑hosting threads:
Privacy and IP control. Your code never leaves your network. There is no negotiation with legal about whether a cloud vendor's data‑handling clause is acceptable. Logs are yours. Embeddings are yours. The model weights themselves never read prompts from anyone but you.
Cost predictability. A Codex subscription bills per use; heavy users in agentic loops can run up surprising token totals because every tool round‑trip prepends the whole working context. Local inference has no per‑token meter — your only ongoing cost is electricity, which on a 170‑watt RTX 3060 under full load comes out to about 4 cents per hour at U.S. average residential rates.
Offline and air‑gapped work. Aircraft, ships, classified networks, conference Wi‑Fi that won't reach api.openai.com — none of it matters if the model lives on your PCIe bus.
The honest tradeoff is capability. The frontier hosted models are still meaningfully smarter than anything you can fit in 12 GB of VRAM. A local 14B coder will refactor a function, write a test, and walk a small bug to root cause. It will not architect a new subsystem the way a frontier model will. That gap is closing every six months, but it is real today.
What VRAM do agentic coding models need?
Open‑weight coding models in 2026 cluster around three sizes: 7B, 14B (sometimes 13B), and 32B (sometimes 27B–34B). VRAM consumption depends almost entirely on quantization. Here are the working numbers from public benchmarks and self‑hosting reports:
| Model size | fp16 (full) | q8 (8‑bit) | q6 | q5 | q4 (4‑bit) | q3 |
|---|---|---|---|---|---|---|
| 7B coder | ~14 GB | ~8 GB | ~6.5 GB | ~5.5 GB | ~4.8 GB | ~3.8 GB |
| 14B coder | ~28 GB | ~15 GB | ~12 GB | ~10 GB | ~9 GB | ~7.2 GB |
| 32B coder | ~64 GB | ~34 GB | ~26 GB | ~22 GB | ~19 GB | ~15 GB |
Add roughly 1–2 GB for the KV cache at a typical 8K context window for agentic loops. That is why a 12 GB card lands cleanly on 14B q4 with room to spare, while an 8 GB card forces you down to a 7B or to aggressive q3 on a 14B (where quality starts to wobble).
Can an RTX 3060 12GB run a useful local coding agent?
Yes — that's the point. Throughput on a Founders or partner RTX 3060 12GB under llama.cpp with CUDA enabled, measured against a typical 14B q4 coder model:
| Phase | Tokens / sec | Notes |
|---|---|---|
| Prefill, 1K prompt | ~900 | Dominated by VRAM bandwidth |
| Prefill, 4K prompt | ~700 | KV cache fills |
| Generation, short | ~28 | Steady‑state token output |
| Generation, long | ~22 | Slows as context grows |
That is fast enough that an interactive request — "fix this function so the test passes" — returns a complete diff in under a minute including reasoning. Multi‑file agentic loops where the model reads three or four files before editing run 3–6 minutes per round. Slower than cloud Codex, but well inside "make coffee and check back" territory, and far faster than any 8 GB rig running the same workload with offload.
For specs and reference benches the TechPowerUp 3060 page is the definitive source: 12 GB GDDR6, 360 GB/s memory bandwidth, 170 W TGP, GA106 silicon. That memory bandwidth is the real bottleneck — local‑LLM throughput is almost entirely VRAM‑bound on this generation, which is why a Ryzen 7 5800X paired with the 3060 leaves the CPU mostly idle during generation.
Quantization matrix for a 14B coder
Quantization is where most people get burned. The drop from fp16 to q8 is essentially free — quality is indistinguishable on coding benchmarks. q6 is also fine. q5 is a touch noisier on long completions. q4 is the practical sweet spot for a 12 GB card: noticeable but small quality loss, fits comfortably, fastest inference. q3 and below trade away enough quality that the agent starts hallucinating imports and misnaming variables.
| Quant | VRAM (14B) | Tokens/sec (3060) | Quality | Notes |
|---|---|---|---|---|
| fp16 | ~28 GB | (doesn't fit) | reference | Needs A100 / dual 4090 |
| q8 | ~15 GB | (doesn't fit on 12 GB) | ~99% | Needs 16 GB |
| q6 | ~12 GB | borderline, slow | ~98% | Just fits, no context headroom |
| q5 | ~10 GB | ~24 | ~96% | Good headroom, real cost |
| q4 | ~9 GB | ~28 | ~93% | Recommended for 3060 12GB |
| q3 | ~7 GB | ~32 | ~85% | Visible degradation |
| q2 | ~5 GB | ~38 | poor | Don't use for coding |
The TL;DR: ship q4 on a 3060 and don't look back unless you can step up to a 16 GB or 24 GB card.
How does context length impact a coding agent's memory budget?
Agentic loops are context‑hungry. A single round of "read these three files, propose a diff, run the test, observe the error, edit again" can easily push 6K–10K tokens of working context. KV cache for a 14B model at q4 grows at roughly 0.25 MB per token, which means an 8K context window consumes about 2 GB of VRAM on top of the model weights. That is why the math above leaves ~1 GB of slack at q4: comfortable for 8K, tight at 16K, infeasible at 32K without dropping to q3 or smaller models.
In practice, most local agent loops cap at 8K and rely on careful retrieval (only the relevant files, not the whole repo) to stay inside that window. That's a design discipline worth adopting even if you have a 24 GB card later, because context isn't free even when it fits — every additional KV token is one more thing the model has to attend to per generation step.
Perf‑per‑dollar: local rig vs cloud Codex subscription
A reasonable build cost in mid‑2026, using readily available parts:
| Component | Part | Cost |
|---|---|---|
| GPU | MSI or ZOTAC RTX 3060 12GB (used) | ~$300 |
| CPU | AMD Ryzen 7 5700X | ~$170 |
| RAM | 32 GB DDR4‑3200 | ~$75 |
| Motherboard | B550 ATX | ~$120 |
| Storage | 1 TB NVMe | ~$70 |
| PSU | 650 W 80+ Gold | ~$80 |
| Case | mid‑tower | ~$60 |
| Total | ~$875 |
A heavy Codex subscription runs roughly $60–$200 per month depending on tier and overage. At $120/month average, break‑even on a $875 rig is about 7–8 months of consistent daily use — and that ignores the resale value of the parts. For occasional use, the math flips: a single $60 monthly subscription saves you the build cost and the maintenance burden for years.
Don't forget electricity. A 3060 under sustained load draws ~170 W. At U.S. average $0.16/kWh, that's 2.7 cents per hour. Even four hours a day adds up to less than $4/month — well under the noise floor in this comparison. Cooling and the rest of the system add another 100 W or so under load. Pugetsystems publishes extensive power and thermal benchmarks for similar builds if you want a more rigorous accounting.
Real‑world gotchas the spec sheet doesn't show
These come up over and over in self‑hosting threads:
- Windows + CUDA + WSL2 wants a fresh nvidia driver. Mismatched driver and CUDA toolkit versions cause silent fallback to CPU inference at 1–2 tok/s. Match your toolkit to the driver, not the other way around.
- PSU sag on a budget 550 W supply. RTX 3060s transient‑spike past 200 W. A cheap 550 W can shut down the rig mid‑inference. 650 W 80+ Gold is the floor for stability.
- Single‑channel RAM kills prefill. Bench numbers above assume dual‑channel DDR4. A single 32 GB stick will cut prefill throughput by ~30%.
- Thermal throttling on small cases. The 3060 is mild but constant. SFF cases with one 92 mm fan run the GPU at 78 °C+ and start clocking down after 20 minutes of sustained generation.
- Disk speed at model load. A 14B q4 model is ~9 GB on disk. A SATA SSD loads it in 25–30 seconds; an NVMe in 6–8. Worth the upgrade.
Bottom line: who should build the local rig
Build the local rig if:
- You work on proprietary code under an NDA or regulatory regime.
- You expect to use an agent daily for 30+ minutes of active driving.
- You want to learn the stack (llama.cpp, ollama, vLLM, fine‑tuning) hands‑on.
- You like owning your tools.
Stay on cloud Codex if:
- You only need an agent for occasional tasks.
- You need frontier‑model capability for complex multi‑subsystem work.
- You don't want to be the sysadmin for your developer tools.
For the buyer who's decided to build, the Ryzen 7 5800X / RTX 3060 12GB combination is the budget benchmark the rest of the market is measured against in 2026. Spending more buys you headroom for larger models (a 24 GB 3090 or 4090 lets you run 32B q4); spending less means dropping to a 7B model and a meaningfully weaker agent.
Related guides
- Best Budget Gaming Monitor in 2026 — pair the rig with a 1440p or 4K display.
- ComfyUI on an RTX 3060 12GB — the same card, different workload.
- GPT‑5.5 Instant vs Local RTX 3060 — direct comparison for chat workloads.
Citations and sources
- The Decoder — OpenAI Codex Can Now Operate Your Windows PC Autonomously
- TechPowerUp — GeForce RTX 3060 Specifications
- Puget Systems Labs — Benchmarking Articles
