Self-Hosted AI Coding Models in 2026: The Practical Review

Quick answer

• The best self-hosted model you can actually run on consumer hardware is Qwen3-Coder 30B — 220 tokens/sec, fits a single 24GB GPU, Apache 2.0 license.
• If you have more horsepower, Qwen3-Coder-Next 80B (~45GB) and Laguna S 2.1 (~67GB) push quality further.
• The absolute best open-weight model is Kimi K3, but it needs a cluster (~1.4TB), not a desktop.
• Open-weight models now score within 3-5 points of proprietary flagships on coding benchmarks — the gap is closing fast.

The state of self-hosted coding AI: August 2026

A year ago, running an AI coding assistant locally meant settling for significantly worse code than you’d get from ChatGPT or Claude. The best open models scored 30-40% on SWE-bench Verified while proprietary models cruised past 70%.

As of August 2026, that gap has collapsed. The best open-weight models now score ~80% on SWE-bench Verified — the same territory as Claude Opus 4.7 and GPT 5.2 Codex from late 2025. On LiveBench’s independent, contamination-aware leaderboard, open-weight Kimi K3 sits at 81.45 on Coding Avg, within striking distance of GPT-5.6 Terra Max Effort at 84.62.

The practical question isn’t “can open models code?” — it’s “which open model fits your hardware, and what compromises does it make?”

How to read this review

Every model below is scored on three dimensions:

• Coding quality — how well it writes, fixes, and reasons about code (SWE-bench Verified, LiveBench Coding Avg)
• Agentic ability — how well it works autonomously: reading files, running commands, self-correcting (LiveBench Agentic Coding Avg, Terminal-Bench)
• Practicality — can you actually run it on hardware you own or can rent?

Models are organized by hardware tier, not raw score. The best model in the world doesn’t matter if you can’t run it.

Tier 1: Runs on your laptop or a single consumer GPU

These models fit on an RTX 4090 (24GB), an M-series Mac with 32GB+ unified memory, or similar. No data center required.

🏆 Qwen3-Coder 30B — The best all-rounder

Developer: Alibaba (Qwen team) | License: Apache 2.0 | Released: 2025 (Qwen3-Coder family)

Benchmarks:

• SWE-bench Verified: 70.6% (self-reported)
• SWE-bench Pro: 44.3%
• Terminal-Bench 2.0: 36.2%

The verdict: Qwen3-Coder 30B is the sweet spot. It’s the fastest model tested at 220 tokens/second — roughly 40x faster than its 80B sibling — and it handles real coding tasks competently. Because only 3.3B parameters are active per token, it runs at the speed of a small model while drawing quality from the full 30.5B pool. It finished complex tasks more token-efficiently than any competitor in independent testing by Atomic Chat, using ~1,840 tokens where others spent 3,000+.

Best for: Daily coding work — adding endpoints, writing tests, refactoring, bug fixes. The default recommendation for anyone with a single 24GB GPU.

Limitations: No thinking/reasoning mode. On complex multi-file architectural changes, it’s noticeably behind frontier cloud models. Not the choice for debugging a race condition across five files.

How to run it:

ollama pull qwen3-coder:30b

Qwen3.6 27B — Best on benchmarks, mixed in practice

Developer: Alibaba (Qwen team) | License: Apache 2.0 | Released: April 2026

Benchmarks:

• SWE-bench Verified: 77.2%
• SWE-bench Pro: 53.5%
• Terminal-Bench 2.0: 59.3%
• LiveCodeBench v6: 83.9%

The verdict: On paper, Qwen3.6 27B beats Qwen3-Coder 30B across almost every benchmark. It’s the highest-scoring model that fits on consumer hardware. But independent testing reveals a gap between benchmarks and reality: in Atomic Chat’s hands-on tests, it produced the best Snake game (scored 80 without crashing) but was the only model that failed a physics simulation task — chaotic movement, unnatural acceleration. As a dense model, all 27B parameters run on every token, making it slower (47 tok/s vs 220) and harder to run than the MoE competitors.

Best for: Tasks that match its benchmark strengths — competitive programming, code completion, single-file work. Test it on your actual use case before committing; its real-world reliability varies more than its benchmark scores suggest.

Limitations: Slower than MoE alternatives. Benchmark scores don’t always translate to real-world reliability. Multimodal (text, image, video), which is a bonus if you need it.

ollama pull qwen3.6:27b

Gemma 4 26B — Best for smaller GPUs

Developer: Google DeepMind | License: Apache 2.0 | Released: April 2026

Benchmarks:

• LiveCodeBench v6: 77.1%
• AIME 2026 (math): 88.3%
• GPQA Diamond (science): 82.3%

The verdict: Gemma 4 26B is the most accessible option. It runs from 12GB of VRAM — meaning it fits on an RTX 4070, a 16GB Mac, or even some higher-end laptops. With Atomic Chat’s Multi-Token Prediction, throughput hits 3x. It’s strong on competitive coding, math, and science benchmarks. But it’s weaker on SWE-bench Verified — large repository tasks with multi-file changes are not its strength. It also tends to be verbose, generating ~3,724 tokens for tasks that Qwen3-Coder handles in ~1,840.

Best for: Developers with 12-16GB GPUs who want fast, local coding assistance for single-file tasks, competitive programming, or quick lookups.

Limitations: Weaker on multi-file repository tasks. Verbose output burns tokens. Not the choice for agentic coding workflows.

ollama pull gemma4:26b

Muse Glimmer 30B — New contender (August 2026)

Developer: Meta | License: Apache 2.0 | Released: August 10, 2026

Benchmarks:

• SWE-bench Pro: 51.2%
• MCP Atlas (tool use): 75.5% (beats Qwen3.6 27B by 13 points)

The verdict: Meta shipped this less than two weeks ago (as of this writing). It’s a dense 30B model that fits a single 24GB GPU, under Apache 2.0. On SWE-bench Pro it scores 51.2 — 4.2 points behind DeepSeek-V4-Pro-Max, a model roughly 50x larger. On tool use (MCP Atlas), it beats Qwen3.6 27B by a decisive 13 points. It hasn’t been benchmarked by independent evaluators like Artificial Analysis or LiveBench yet, so treat these numbers as provisional. But the early signal is strong: a 30B model trading blows with 27B-80B competitors on agentic and tool-use tasks.

Best for: Tool-use-heavy workflows (MCP servers, agentic coding). Early adopters who want the newest thing. Worth watching closely as independent benchmarks arrive.

Limitations: Brand new — community support and tooling are immature. No independent benchmark scores yet. Loses to Qwen3.6 27B on TerminalBench 2.1.

Tier 2: Needs a serious workstation (45-100GB VRAM)

These models need an A6000, a 64-128GB Mac Studio, or a multi-GPU workstation. They deliver a meaningful quality jump over Tier 1.

Qwen3-Coder-Next 80B — More reasoning, more hardware

Developer: Alibaba (Qwen team) | License: Apache 2.0 | Released: February 2026

The verdict: Qwen3-Coder-Next is the 80B big sibling. Despite 80B total parameters, only 3B are active per token — Qwen reports quality comparable to models with 10-20x more active compute. On benchmarks it scores 70.6% SWE-bench Verified and 44.3% SWE-bench Pro. But at 5.5 tokens/second on consumer hardware, it’s slow — 40x slower than its 30B sibling. The use case: give it a long-horizon task, leave it running overnight, review in the morning.

Best for: Developers with 48GB+ of VRAM who need stronger reasoning and are willing to trade speed for quality. Long-running agentic tasks.

Limitations: Very slow on consumer hardware. Needs ~45GB VRAM minimum.

Laguna S 2.1 — Best agentic coder in its weight class

Developer: Poolside | License: OpenMDW-1.1 | Released: July 2026

Benchmarks:

• Terminal-Bench 2.1: 70.2% (11th on overall leaderboard)
• SWE-bench Pro: 59.4% (highest of any model that fits a single workstation)
• SWE-bench Multilingual: 78.5%

The verdict: Laguna S 2.1 is purpose-built for agentic coding. Poolside trained it on 409K agentic and non-agentic environments, including 83K terminal tasks. On Terminal-Bench 2.1, it places 11th overall — ahead of open models several times its size. On SWE-bench Pro, its 59.4% is the highest of any model in Tier 2. It has a thinking mode (on by default) that lifts Terminal-Bench from 60.4% to 70.2%. Poolside demoed it building a working browser engine in vanilla JavaScript in ~50 minutes. The tradeoff: it needs 67-96GB of VRAM even at low-bit quantization.

Best for: Agentic coding on a high-end Mac Studio (96-128GB) or multi-GPU workstation. Long-horizon autonomous tasks.

Limitations: Heavy hardware requirements. Occasionally produces malformed JSON in nested tool calls. Smaller community than Qwen models.

Tier 3: Cluster-only — the absolute best, if you have the hardware

These models need multi-GPU servers. If you have access through an API, use that instead. Self-hosting is for organizations with existing GPU clusters.

Kimi K3 — #1 open-weight model, cluster required

Developer: Moonshot AI | License: Bespoke (self-hosting allowed, revenue triggers for MaaS) | Released: July 2026

Benchmarks:

• LiveBench Coding Avg: 81.45 (#1 open-weight)
• LiveBench Agentic Coding Avg: 57.58 (#1 open-weight)
• LMArena Frontend Code Arena: #1 (1,679 points, ahead of Claude Fable 5 at 1,631)

The verdict: Kimi K3 is the largest open-weight model ever released at 2.8 trillion parameters. On LiveBench’s independent, contamination-aware leaderboard, it’s the #1 open-weight model on both Coding Avg and Agentic Coding Avg. On LMArena’s Frontend Code Arena, it debuted at #1 overall — ahead of every proprietary model. But: the weights are ~1.4TB at their native MXFP4 precision (quantization-aware training, so there’s no further compression headroom). Moonshot recommends 64+ accelerators. This is not a self-host model for individuals. If you want K3 quality without the hardware, the API is $3/M input, $15/M output — not cheap, but cheaper than building a cluster.

Best for: Organizations with GPU clusters who want the best open-weight coding model. Everyone else: use the API or look at GLM-5.2.

Limitations: Requires a cluster. Bespoke license (not Apache/MIT — read it before commercial use). API pricing is competitive but not cheap.

GLM-5.2 — Best model that fits a single server

Developer: Z.AI | License: Open Source | Released: June 2026

Benchmarks:

• LiveBench Coding Avg: 79.65
• LiveBench Agentic Coding Avg: 51.92
• SWE-bench Pro: 62.1 (#1 open-weight)
• Artificial Analysis Intelligence Index: 51.1
• GDPval-AA v2 (agentic): 1,524 (level with GPT-5.5 xHigh)

The verdict: GLM-5.2 is the strongest model you can fit on a single 4-GPU or 8-GPU server. On SWE-bench Pro — the hardest coding benchmark — it leads all open-weight models at 62.1. On Artificial Analysis’s agentic benchmark (GDPval-AA v2), it scores effectively level with GPT-5.5 xHigh. At ~370GB for 4-bit weights, it fits a 4x H100/H200 node. If you have access to a GPU server and want the best quality short of K3, this is it.

Best for: Teams with access to a 4-8 GPU server. The practical ceiling for self-hosted coding AI in August 2026.

Limitations: Still needs a server, not a workstation. 2-bit quantizations exist (~239GB) but quality takes a real hit.

DeepSeek V4 Pro — The API sweet spot

Developer: DeepSeek | License: Open Source | Released: April 2026

Benchmarks:

• LiveBench Agentic Coding Avg: 42.63
• SWE-bench Verified (Pro-Max variant): 80.6%
• LiveCodeBench (Pro-Max): 93.5%

The verdict: DeepSeek V4 Pro is a strong model that’s slightly behind GLM-5.2 on most independent benchmarks but has a critical advantage: its API is one of the cheapest in the frontier class at $0.27/M input tokens. The Pro-Max variant scores 80.6% on SWE-bench Verified — tied with Gemini 3.1 Pro — but needs even more hardware. For most developers, DeepSeek’s API is the play: frontier-class coding at budget prices.

Best for: API users who want frontier-class quality at $0.27/M input. The cheapest way to get ~80% SWE-bench Verified performance.

Limitations: Self-hosting needs a full 8-GPU node. The API, while cheap, has higher latency than Anthropic/OpenAI and occasional capacity issues during peak hours.

How to choose: a decision guide

Do you have a 24GB+ GPU or 32GB+ Mac?
├── Yes → Qwen3-Coder 30B (best all-rounder)
│        or Qwen3.6 27B (better benchmarks, slower)
│        or Gemma 4 26B (fits 12-16GB)
│
├── No, but I have 12-16GB GPU → Gemma 4 26B
│
├── I have 48-96GB (workstation/Mac Studio)
│   └── Qwen3-Coder-Next 80B (stronger reasoning)
│       or Laguna S 2.1 (best agentic)
│
├── I have a GPU server (4-8 GPUs)
│   └── GLM-5.2 (best single-server model)
│
└── I have no GPU but want cheap frontier quality
    └── DeepSeek V4 API ($0.27/M input)
        or Qwen3-Coder 30B on CPU (GGUF, slow but free)

Tools for running local models

• Ollama — Easiest way to get started. ollama pull qwen3-coder:30b and you’re coding. macOS, Linux, Windows.
• LM Studio — Best GUI for desktop users. Browse Hugging Face, download models, chat with them. Good for non-terminal users.
• vLLM — Production-grade serving. OpenAI-compatible API. Best for multi-user setups or integrating with IDEs.
• llama.cpp / GGUF — Run models on CPU with massive RAM. A Mac Studio with 192GB unified memory can run models that need 150GB+ VRAM on GPU — slowly, but it works.

Benchmarks explained

When comparing model scores, know what you’re looking at:

Important: Vendor self-reported scores trend higher than independent evaluations. LiveBench is contamination-aware and rotates questions monthly — its scores are the most trustworthy comparison across models. When a model’s score comes from the vendor and hasn’t been independently verified, I’ve noted it.

Where this bites vibecoders

The vibecoder’s relationship with self-hosted models often goes: download the biggest model that fits → run it → disappointed → go back to Claude. The mistake is equating size with quality for your specific tasks. A 30B model tuned for coding (Qwen3-Coder) will outperform a 120B general-purpose model (Mistral Medium 3.5) on your actual work. Match the model to the task, not the parameter count. And run the models you’re considering against your real tasks — benchmarks are directional, not definitive.

Checklist

• Audit your hardware: GPU VRAM, unified memory, or CPU RAM available
• Install Ollama or LM Studio (5 minutes)
• Pull Qwen3-Coder 30B as a baseline
• Test it on 10 real tasks from your actual workflow
• Compare quality and speed against your current cloud model
• If quality is sufficient, route 70%+ of coding tasks to local, reserve cloud for hard 30%
• Set up model routing: simple edits → local, complex reasoning → cloud
• Monitor token savings and adjust

FAQ

Can a self-hosted model really replace Claude or GPT-4 for coding?

In August 2026: yes, for many tasks. The best open-weight models score ~80% on SWE-bench Verified, comparable to Claude Opus 4.7 and GPT 5.2 Codex from late 2025. For complex multi-file reasoning, frontier cloud models still lead, but the gap is now 3-5 points on independent benchmarks, not 20. For 80% of daily coding tasks — adding endpoints, writing tests, refactoring — a good local model is indistinguishable from a cloud model.

What hardware do I need to run a coding model locally?

Three tiers: (1) Laptop/consumer GPU — Qwen3-Coder 30B or Gemma 4 26B, ~18-22GB VRAM at Q4 quantization, runs on an RTX 4090 or 32GB+ Mac. (2) High-end workstation — Qwen3-Coder-Next 80B, ~45GB VRAM, needs an A6000 or 64GB+ Mac. (3) Server/cluster — GLM-5.2 (~370GB), DeepSeek V4 (~430GB), Kimi K3 (~1.4TB) — multi-GPU nodes only. Most vibecoders should start in tier 1.

Is Qwen3-Coder 30B really as good as people say?

It’s the best balance of speed, quality, and hardware requirements as of August 2026. It runs on a single 24GB GPU, generates ~220 tokens/second, and handles real coding tasks competently. It’s not as strong as Opus on complex multi-file reasoning, but for 80% of daily work — endpoints, tests, refactoring, bug fixes — it’s excellent. Apache 2.0 license, zero API costs.

What about DeepSeek V4 — can I run that?

DeepSeek V4 Pro is a 1.6T parameter MoE with 49B active parameters. Even at 4-bit quantization it needs ~430GB VRAM — roughly 8x H100 80GB. This is not a consumer or prosumer model. If you have access to a GPU cluster, it’s one of the strongest open-weight coders (80.6% SWE-bench Verified). If you don’t, use the DeepSeek API at $0.27/M input tokens — it’s one of the cheapest frontier-class APIs available.

What about CodeLlama or StarCoder?

They’ve been surpassed. CodeLlama 70B was strong in 2024 but scores in the 40-50% range on current benchmarks — well behind Qwen3-Coder, Gemma 4, and DeepSeek V4. StarCoder2 is a capable fill-in-the-middle model but not competitive as a chat/agent coding assistant. The models reviewed here represent the state of the art as of August 2026.

Related topics

• How to Optimize Token Usage When Coding with AI
• How to Make Your Codebase AI-Friendly
• How to Choose the Right AI Coding Tool for Your Workflow
• What Is Context Engineering?
• How to Write a Spec an AI Coding Agent Can Actually Follow

Sources

• Pinggy — Best Open Source Self-Hosted LLMs for Coding in 2026
• Atomic Chat — Best Local LLM for Coding in 2026
• Kilo AI — Best Open Source AI Models for Coding (2026)
• LiveBench Leaderboard
• Artificial Analysis — Model Intelligence Index
• ThunderCompute — Best Open Source LLMs (August 2026)
• Local AI Zone — Top 20 Open-Source Coding Models 2026