For the cheapest plausible 2026 local coding rig — an RTX 3060 12GB — the best fit is Qwen3.6-Coder 14B at q5_K_M or DeepSeek-Coder-V3 14B at q4_K_M. Both fit fully in VRAM, both clear 25 tokens per second on a 5700X, and both land within 6–10 points of Claude Opus 4.8 on HumanEval-Plus. You will not match Opus 4.8 on agentic tasks, but for everyday code completion and review, the gap is much smaller than it used to be.
Why this article exists
Anthropic's Claude Opus 4.8 launch raised the agentic-coding bar again. Per the GDPval-AA leaderboard, Opus 4.8 now sits at the top of the agentic-coding ranking with a meaningful gap to the runners-up. That kind of jump always prompts the same question on r/LocalLLaMA the morning after: what can I run locally that gets me most of the way there for free?
The honest answer in 2026 is: more than ever, on a smaller card than people assume. A 12 GB RTX 3060 — the most common card in the Steam Hardware Survey above 8 GB — can run a current 14B-parameter coding model fully in VRAM at q5 quantization with 16K of context. That model will close, file-level rename, write a unit test, fix a stack trace, and review a small diff at quality that is roughly within an order of magnitude of an API call to Opus 4.8, at zero per-token cost.
What it will not do is run a 12-hour agentic task in Cursor that spans 40 files and uses tool-calls to bash, the web, and a Postgres MCP. That is a different workload. This piece is about choosing a local coding model that runs well on a 12 GB card, knowing where the cliff is, and knowing when to fall back to the API.
We do not run our own coding-LLM lab. All numbers below are synthesized from publicly available benchmarks: the Qwen blog, DeepSeek's official posts, Hugging Face model cards, and the BigCode HumanEval leaderboard.
Key takeaways
- Qwen3.6-Coder 14B and DeepSeek-Coder-V3 14B are the two strongest local coding options that fit fully in 12 GB of VRAM at q5/q4 respectively.
- Claude Opus 4.8 is roughly 10–15 points ahead on agentic SWE-bench tasks but only 6–10 points ahead on isolated HumanEval-Plus problems.
- Generation throughput on a stock 12 GB 3060 with a 5700X is 25–40 tok/s for 14B q4–q5 models, fast enough for inline completion in an IDE.
- Context window is the practical cliff: 16K fits comfortably; 32K starts forcing layer offload at q5; 128K is API-only territory on 12 GB.
- Break-even for "build a rig vs pay the API" lands around 4–6 months of moderate use at current Opus pricing.
What did Claude Opus 4.8 actually change for agentic coding?
The two changes that matter for the local-vs-API question are the reported GDPval-AA score and the new tool-use latency profile. Opus 4.8 is consistently faster on multi-turn tool sequences than 4.7 was — fewer wasted turns, more successful first-shot edits — and that is what shows up in the SWE-bench-Verified delta. For a developer using Cursor, Claude Code, or a similar agentic harness, the practical effect is that Opus 4.8 finishes a 5-tool task in fewer turns and with fewer rollbacks.
That dimension is the one local 14B models do not match. They are roughly competitive at generating a single correct function from a clear spec; they are noticeably behind at planning a 30-step refactor across an unfamiliar codebase. If your local use case is the first kind, this changes very little. If it is the second, Opus 4.8 widened a gap that was already there.
Which local code models realistically fit 12 GB of VRAM?
A 14B model at q4–q5 is the sweet spot for a 12 GB card. Smaller models (7B) leave VRAM unused and underperform; larger models (32B+) force partial CPU offload and drop generation speed by an order of magnitude. The current set worth considering, as of mid-2026:
- Qwen3.6-Coder 14B — current top of the BigCode leaderboard among models under 20B parameters. Strong on multi-language completion, weak on long-context refactors.
- DeepSeek-Coder-V3 14B — the V3 generation moved DeepSeek decisively ahead of V2 on Python and TypeScript. Roughly tied with Qwen3.6-Coder on HumanEval-Plus and slightly ahead on EvalPlus.
- Code Llama 13B (legacy) — 2024-era, still works, but clearly behind the 2026 entries above. Mention it only because it shows up in older comparisons.
- Phi-4 14B — Microsoft's general-purpose 14B with strong code performance. Good fallback if Qwen/DeepSeek licenses are a concern for your stack.
The 32B-class models — Qwen3.6-Coder 32B, DeepSeek-Coder-V3 33B — are better, but they do not fit in 12 GB and the partial-offload tax is severe.
Spec table: candidate code models — params, quant, VRAM at q4, context window
| Model | Params | Quant | Weights VRAM | KV cache @ 16K | Total VRAM | Fits 12 GB? |
|---|---|---|---|---|---|---|
| Qwen3.6-Coder 7B | 7B | q5_K_M | ~5.0 GB | ~0.6 GB | ~5.8 GB | Easily |
| Qwen3.6-Coder 14B | 14B | q5_K_M | ~9.7 GB | ~1.2 GB | ~11.1 GB | Yes |
| Qwen3.6-Coder 14B | 14B | q4_K_M | ~8.3 GB | ~1.2 GB | ~9.7 GB | Yes, comfortably |
| DeepSeek-Coder-V3 14B | 14B | q4_K_M | ~8.4 GB | ~1.1 GB | ~9.7 GB | Yes |
| Phi-4 14B | 14B | q5_K_M | ~9.5 GB | ~1.0 GB | ~10.7 GB | Yes |
| Qwen3.6-Coder 32B | 32B | q4_K_M | ~19.0 GB | ~2.0 GB | ~21.5 GB | No |
| DeepSeek-Coder-V3 33B | 33B | q4_K_M | ~19.5 GB | ~2.0 GB | ~22.0 GB | No |
The "fits 12 GB" column assumes 16K context with FP16 KV cache. Dropping to q8 KV cache buys you about 600 MB.
Benchmark table: HumanEval-Plus and SWE-bench scores vs Opus 4.8 reference
Numbers below are from publicly reported leaderboards as of late May 2026. The BigCode HumanEval-Plus leaderboard and the SWE-bench-Verified leaderboard are the underlying sources. Opus 4.8 numbers are from Anthropic's model announcement.
| Model | HumanEval-Plus | EvalPlus (avg) | SWE-bench-Verified |
|---|---|---|---|
| Claude Opus 4.8 (API) | ~93 | ~91 | ~71 |
| Claude Sonnet 4.6 (API) | ~90 | ~89 | ~64 |
| Qwen3.6-Coder 32B (local, q4) | ~86 | ~84 | ~38 |
| Qwen3.6-Coder 14B (local, q5) | ~83 | ~80 | ~28 |
| DeepSeek-Coder-V3 14B (local, q4) | ~82 | ~79 | ~27 |
| Phi-4 14B (local, q5) | ~78 | ~75 | ~22 |
| Qwen3.6-Coder 7B (local, q5) | ~74 | ~71 | ~15 |
The pattern is clear: on isolated completion benchmarks, the 14B-on-12GB models trail Opus 4.8 by ~10 points. On agentic SWE-bench, the gap is closer to 40+ points. The gap on day-to-day code completion is much smaller than the gap on autonomous refactoring.
How close can a 12 GB local model get to a frontier API for everyday tasks?
For inline code completion, function rewrites, and "explain this stack trace" prompts, Qwen3.6-Coder 14B at q5_K_M is genuinely competitive. The errors it makes tend to be small: wrong import path, slightly wrong type signature, missed edge case in a regex. Those errors are easy to spot in an IDE and cheap to fix.
For multi-file refactors, planning a migration, or "look at this codebase and tell me what's wrong," the local model falls behind quickly. It is not that it is wrong about any one fact — it is that it loses the thread across the conversation. Opus 4.8's edge here is partly raw capability and partly the agentic harness around it (tool use, memory, planning) that you do not get from a single-model llama.cpp call.
A pragmatic split a lot of developers settle on: local 14B for the 90% of completion-style tasks, API for the 10% of agentic work. That preserves most of the privacy and zero-cost benefit while still letting you reach for Opus when you need it.
Quantization matrix: VRAM and quality loss for Qwen3.6-Coder 14B
| Quant | Weights VRAM | HumanEval-Plus | Notes |
|---|---|---|---|
| q3_K_M | ~6.5 GB | ~76 | Noticeable quality loss; use only if running other apps on GPU |
| q4_K_M | ~8.3 GB | ~81 | Safe minimum; common default |
| q5_K_M | ~9.7 GB | ~83 | Best balance for 12 GB |
| q6_K | ~11.5 GB | ~84 | Tight on 12 GB; KV cache must be q8 |
| q8_0 | ~14.9 GB | ~84 | Does not fit; requires offload |
q5_K_M is the practical answer on a 12 GB card. The quality gap between q5 and q8 is barely measurable on coding benchmarks, but the VRAM gap is the difference between "fits" and "spills to CPU."
Context-length impact: fitting a repo's files in the prompt on 12 GB
Modern coding models advertise 32K or 128K context, but the question on a 12 GB card is how much of that you can actually hold. KV cache for Qwen3.6-Coder 14B at FP16 grows by about 75 MB per 1,000 tokens. At 32K context that is roughly 2.4 GB just for the KV cache, which on a 12 GB card forces the runtime to start offloading weights — at which point generation falls from 30 tok/s to 8 tok/s.
Practical guidance:
- 16K context: comfortable at q5_K_M; the right setting for most IDE workflows.
- 24K context: drop KV to q8 and you stay fully on GPU at q5_K_M.
- 32K context: drop to q4_K_M weights and q8 KV cache; expect minor regression in completion quality.
- 64K+ context: not realistic on 12 GB without heavy offload.
For "feed me the whole repo" use cases, you want a 24 GB card or an API call. For "look at these 3 files and refactor this function," 16K is more than enough on 12 GB.
Perf-per-dollar: local rig vs API subscription break-even math
The break-even point depends entirely on how many tokens you push through Opus 4.8. A rough sketch using publicly listed pricing:
- Opus 4.8 typical cost: ~$15 input / $75 output per million tokens (per Anthropic's pricing page).
- Moderate developer workload: roughly 30M input + 5M output per month with cache-heavy tooling, or about $825/month.
- Cost of a 3060 12GB + supporting parts: ~$650 for a used 3060 plus a Ryzen 7 5700X, 32 GB DDR4, and a basic B550 board (assuming you already have a case and PSU).
If your real workload is the moderate sketch above, the rig pays for itself in roughly 4–6 weeks of substituted use. If your use is closer to "occasional," the API is cheaper and easier. The break-even is genuinely workload-dependent — the rig wins for heavy daily use, the API wins for sporadic use.
When you should just use the API instead
There are three honest "use the API" cases:
- You actually need Opus-4.8-class agentic performance. If your job is autonomous refactors and you have measured a quality gap that hurts, do not fight the math. Buy the API.
- You bill hours that exceed the inference cost by 10x. A senior engineer's hour is worth more than a month of Opus calls. The local rig has to actually save you wall-clock time to be worth the setup tax.
- Privacy or air-gap is not a hard requirement. If the privacy story is "would be nice but not mandatory," the API is the path of least resistance.
The flip side, when local wins: privacy-mandatory contexts (healthcare, finance, legal), high-volume completion (auto-complete that fires hundreds of times an hour), offline work, and the not-small psychological benefit of running your tools on hardware you own.
Common pitfalls on 12 GB local coding setups
- Using a chat-tuned model for code. Qwen3.6 base/chat is not Qwen3.6-Coder. Coder variants are post-trained on code and meaningfully better at it; download the right one.
- Defaulting to q4 when q5 fits. On a 14B model, q5_K_M is meaningfully better than q4_K_M for code and still fits 12 GB. Check the math before quantizing harder than necessary.
- Skipping the KV cache quantization flag. llama.cpp defaults to FP16 KV, which is wasteful on a constrained card.
--cache-type-k q8_0 --cache-type-v q8_0buys ~600 MB. - Running on Windows with no driver tuning. WDDM driver overhead on Windows costs you ~400 MB of usable VRAM compared with a clean Linux setup with the proprietary driver.
Bottom line
Opus 4.8 is the new top of the agentic-coding mountain. For the 90% of coding use cases that look like "complete this function, write this test, fix this stack trace," a 14B local model on a $250 RTX 3060 12GB closes most of the gap at zero per-token cost. The right pick is Qwen3.6-Coder 14B at q5_K_M for general code, with DeepSeek-Coder-V3 14B as a near-identical alternative and Phi-4 14B as the license-friendly fallback.
You will not match Opus on autonomous, multi-file agentic tasks. You will not match it on 64K-token reasoning over a whole codebase. But you will match it well enough on inline completion that the API is no longer the only sensible answer. That is the lasting story of the 12 GB tier in 2026.
Related guides
- Qwen3.6 35B on a Single RTX 3060 12GB: What Actually Fits
- Best GPU for 1440p Esports in 2026: Why the RTX 3060 12GB Still Delivers
- Best Budget Ryzen Gaming PC Build for 1080p in 2026
Citations and sources
- Anthropic — Claude Opus 4.8 announcement — Opus 4.8 GDPval-AA and SWE-bench reference numbers.
- Anthropic pricing page — Opus 4.8 input/output token costs used in break-even math.
- Qwen team blog — Qwen3.6-Coder release details and parameter counts.
- DeepSeek — DeepSeek-Coder-V3 model card and benchmark claims.
- BigCode HumanEval-Plus leaderboard — per-model HumanEval/EvalPlus scores synthesized into the benchmark table.
- SWE-bench Verified leaderboard — agentic SWE-bench-Verified scores.
- TechPowerUp RTX 3060 page — VRAM and memory bandwidth references.
- Steam Hardware Survey — VRAM tier distribution context.
This piece is editorial synthesis based on publicly available information. No independent first-party benchmarking is reported.
