Best LLM for Coding in 2026: 9 Models Ranked

In February 2025, Claude 3.7 Sonnet posted 62.3% on SWE-bench Verified, or 70.3% with a custom scaffold, while the best open-weight model of the moment, DeepSeek-R1, reported 49.2% in its paper.

That was a gap of 13 to 21 points, depending on how generous you were with scaffolding.

By September 2026, the independent Vals AI board for SWE-bench Verified has Claude Opus 5 at 97.0% and the open-weight DeepSeek V4 Pro 0813 at 96.4%, and Vals archived the benchmark because it became saturated.

The frontier moved to harder agentic evaluations like SWE-bench Pro and Terminal-Bench 4.0, open weights caught up on the old ones, and the "best LLM for coding" question turned into "best for what, on what hardware, at what price."

I'll answer that question for the 9 models I would actually consider using today, and the short version is that Claude Opus 5.5 is the one most teams should start with.

One note before the rankings: this article is about the models themselves, not the tools wrapped around them. If you want the Cursor, Copilot, and Windsurf comparison, our roundup of the best AI coding assistants in 2026 covers that.

In a Nutshell: The Best Coding LLMs in September 2026

Claude Opus 5.5 is now both the strongest coding model on most benchmarks and the one most developers should default to, Claude Fable 5.1 is the one to escalate to for the longest-horizon work, and Qwen3.8-27B is the open-weight model to run on one GPU. Here are the best picks for the purpose:

• Best overall for agentic coding: Claude Opus 5.5 (Anthropic), 89.9% SWE-bench Pro and 66.4% Terminal-Bench 4.0, at $4 input and $20 output per million tokens.
• Best for the longest-horizon work: Claude Fable 5.1 (Anthropic), 81.2% SWE-bench Pro and the top Terminal-Bench 2.1 score on Artificial Analysis (91.4%), at $10 input and $50 output per million tokens.
• Best OpenAI model for coding: GPT-6 Astra (OpenAI), first on the tbench.ai Terminal-Bench 4.0 agent leaderboard at 58.2%, and level with Opus 5.5 at 59.6% on Artificial Analysis's run.
• Best value from a frontier lab: Gemini 3.8 Flash (Google), 89.4% Terminal-Bench 2.1 for $0.75 input and $3.75 output per million tokens through December 31, 2026.
• Best open weights via API: DeepSeek V4.1 Flash, MIT license, 90.6% Terminal-Bench 2.1, $0.60 per million output tokens off-peak.
• Best open weights you cannot run at home: Kimi K3 (Moonshot AI), 2.8 trillion parameters, 88.3% Terminal-Bench 2.1.
• Best local model on a 24 GB GPU: Qwen3.8-27B (Alibaba), Apache 2.0, 73.0% Terminal-Bench 2.1, 16.5 GB at UD-Q4_K_M.
• Best local model for a 128 GB workstation: Laguna S 2.1 (Poolside), 118B parameters with only 8B active, 1M context.
• Best fast local model for older hardware: Qwen3-Coder-Next, 80B total but 3B active, 70.6% SWE-bench Verified.

Every score above is vendor-published unless otherwise noted. The rest of the article explains how I got to those picks and where each one breaks.

Why Is This List About Models and Not Coding Assistants?

A coding LLM is the model that reads your prompt and writes tokens, while a coding assistant is the harness that feeds it files, runs its commands, and shows you diffs.

Claude Code, Codex, Cursor, GitHub Copilot, and Windsurf are harnesses. Claude Opus 5.5, GPT-6 Astra, and Qwen3.8-27B are models, and the harness changes the score more than most people expect.

Anthropic's own Claude Opus 4.8 launch post makes this concrete in a footnote.

It reports every model's Terminal-Bench 2.1 score on the public Terminus-2 harness, then notes that GPT-5.5's number rises to 83.4% inside OpenAI's Codex CLI. Same weights, different plumbing, different result.

That is why the rankings below come with the harness attached wherever I could find it. If you are new to how these models work under the hood, our guide to what a large language model (LLM) is is a 15-minute read that will make the rest of this article easier to follow.

Which Benchmarks Actually Matter for Coding LLMs?

The benchmarks that matter for coding LLMs in 2026 are SWE-bench Pro, Terminal-Bench (versions 2.1 and 4.0), and, for the open-weight models that still report it, LiveCodeBench v6. SWE-bench Verified was the standard for 2 years and is now too saturated to separate the top models.

Before I rank anything, here is what each number in the model entries means.

SWE-bench Verified is saturated

SWE-bench Verified is a set of 500 human-validated GitHub issues from popular Python repositories; the model gets the repository and the issue text and has to produce a patch that passes the hidden unit tests.

OpenAI introduced the Verified subset in 2024 because the original SWE-bench contained tasks with underspecified issues or broken tests. It is still the most-quoted coding number, which is exactly the problem.

The Vals AI leaderboard, which runs every model through the same minimal bash-only agent, put Claude Opus 5 at 97.0%, DeepSeek V4 Pro 0813 at 96.4%, and GPT-5.6 Sol at 96.2% in its September 1, 2026 update, then marked the benchmark archived.

When 3 models from 3 labs sit within a point of each other and 4 points of the ceiling, the metric has stopped discriminating. I still quote it for the older and smaller models because it is the number their cards report, but I do not rank on it.

SWE-bench Pro is the harder replacement

SWE-bench Pro, maintained by Scale AI, contains 1,865 tasks across 41 professional repositories, with a 731-task public split and held-out private sets. On September 22, 2026, Scale released SWE-Bench Pro V2, which cuts the public set to 642 tasks after dropping 89 it found invalid, so check which version a score was run on.

The average fix touches 107.4 lines across 4.1 files, and the repositories span multiple languages rather than just Python. When the SWE-bench Pro paper came out in September 2025, the best models scored around 23%.

A year later, Anthropic's Fable 5.1 system card reports 81.2% for Fable 5.1 and 79.2% for Opus 5, and OpenAI's GPT-5.6 launch table reports 64.6% for GPT-5.6 Sol. Three weeks after the Fable card, the Opus 5.5 system card pushed the top score to 89.9%.

Those are vendor runs, averaged over 5 trials at max effort in Anthropic's case. Scale's own public leaderboard lags the vendor numbers by months, so I treat the vendor figure as the ceiling and the leaderboard as the floor.

Terminal-Bench 2.1 and 4.0

Terminal-Bench gives a model a live shell inside a container and a task like "train this model," "fix this build," or "recover this corrupted archive," then grades the artifacts it produces.

The 2.1 release is 89 curated tasks across software engineering, system administration, data processing, and security, and Artificial Analysis scores it with the Terminus 2 harness as pass@1 averaged over 3 runs. It is the single number I weigh most heavily for anyone building or using coding agents.

Terminal-Bench 4.0, hosted by Stanford, Harbor, and the Laude Institute at tbench.ai, is the new frontier set.

Anthropic's Opus 5.5 system card describes it as 66 tasks skewed toward computational biology, physics simulation, CAD, formal proofs, and GPU performance work, with longer timeouts so the harness matters less.

On the tbench.ai agent leaderboard, GPT-6 Astra still leads at 58.2% with Claude Fable 5.1 at 57.9%, but Claude Opus 5.5 does not have an agent entry there yet. On model-level runs, Artificial Analysis has Opus 5.5 and Astra tied at 59.6%, and Vals AI puts Opus 5.5 first at 61.6%, though Vals notes that figure drops to 53.5% if you count the tasks its safeguards handed to a fallback model as failures. This is where the frontier separates from the pack.

LiveCodeBench v6 catches memorization

LiveCodeBench, introduced in the 2024 paper by Jain and colleagues, continuously collects problems from LeetCode, AtCoder, and Codeforces and time-stamps each one so you can evaluate a model only on problems published after its training cutoff.

Version 6 is the current window on the public leaderboard. It measures algorithmic reasoning rather than repository-scale engineering, which is why it stayed useful for interview-style and data-structures work.

The frontier labs mostly stopped reporting it in 2026, so the numbers I have are from open-weight models: the April DeepSeek V4 Pro preview at 93.5%, Qwen3.8-27B at 90.3%, and Kimi K2.6 at 89.6%. Gemini 3.1 Pro reports a related metric, a LiveCodeBench Pro Elo of 2,887.

How I read a vendor benchmark table

A vendor benchmark table is a best case: their harness, their effort setting, their number of trials. I look for an independent replication on Artificial Analysis, Vals AI, or the tbench.ai leaderboard before I believe a gap smaller than 3 points.

Our primer on LLM benchmarks and how to compare models walks through the major leaderboards, and our piece on what MMLU measures is a good reminder that a knowledge benchmark tells you almost nothing about whether a model can fix a flaky test.

For building your own evaluation harness, our guide to LLM evaluation metrics and methodologies is the one I point junior colleagues to first.

With those benchmarks defined, here is how the 9 models score on them, starting with the cloud frontier.

What Are the Best Cloud Frontier Models for Coding?

The best cloud frontier models for coding in September 2026 are Claude Opus 5.5, Claude Fable 5.1, GPT-6 Astra, and Gemini 3.8 Flash, and all 4 ship a context window of roughly 1M tokens.

The differences are price, effort settings, and which benchmark each lab optimized for.

I list them in the order I would recommend them to a team that can afford any of them.

1. Claude Opus 5.5 (Anthropic)

Claude Opus 5.5 is Anthropic's new Opus-tier flagship, released September 22, 2026, and it is now the coding model I would recommend to almost everyone. I did not expect to write that 2 months after Opus 5. Anthropic's launch post says it performs at Fable 5.1's level on most work while costing 40% less to run than Opus 5, and its models overview now tells developers to start with Opus 5.5 and reach for Fable 5.1 on demanding long-horizon work or when evals on Opus 5.5 fall short.

The Opus 5.5 system card reports 89.9% on SWE-bench Pro, 74.2% on DeepSWE v1.1, and 66.4% on Terminal-Bench 4.0 at xhigh effort, ahead of Fable 5.1 on every coding row Anthropic published. The independent numbers are closer: Artificial Analysis has it tied with GPT-6 Astra at 59.6% on Terminal-Bench 4.0, and Vals AI puts it first at 61.6% on Terminal-Bench 4.0 and 87.6% on Terminal-Bench 2.1. Both Vals numbers include safeguard fallbacks; counting those as failures drops them to 53.5% and 79.8%.

Key features:

• $4 per million input tokens and $20 per million output tokens, 20% below Opus 5, with cache reads down 60% to $0.20 per million
• 1M-token context, 128K output, adaptive thinking that cannot be switched off, and a default effort of medium rather than high
• 57.8% on CursorBench 4.0 at max effort, the top score on Cursor's leaderboard; at medium it scores 52.5%, still above Fable 5.1 at max
• Available on the Claude API as claude-opus-5-5, plus Amazon Bedrock, Google Cloud, and Microsoft Foundry

Best for: daily coding, codebase-wide migrations, and code review. It replaces Opus 5 outright at a lower price, and Claude Code now uses it as the default Opus model. Our Claude Opus 5.5 guide covers the launch, and our GPT-6 Sol vs Claude Opus 5.5 comparison includes a hands-on test.

Trade-off: the 40% saving applies at default effort. At max effort, Artificial Analysis found it used far more tokens than Opus 5, so its cost per Intelligence Index task ($5.98) landed almost level with Opus 5's ($5.86). It also ships with Fable-style safeguards that route most cybersecurity tasks to Opus 4.8, and migrating code needs care, because requests with thinking disabled or forced tool use now return errors.

2. Claude Fable 5.1 (Anthropic)

Claude Fable 5.1 is the publicly available version of Anthropic's Mythos-class model, released on September 1, 2026, and it is the model I escalate to when Opus 5.5 runs out of road. Anthropic's launch page states that Fable 5.1 and Claude Mythos 5.1 are the same model with different safeguards.

The numbers from the Fable 5.1 system card are 81.2% on SWE-bench Pro and 55.8% on Terminal-Bench 4.0. Artificial Analysis independently measured 91.4% on Terminal-Bench 2.1 at max effort, still the top score on that board.

Key features:

• 1M-token context window and 128K output tokens
• Adaptive thinking is always on
• Prompt-cache reads dropped 75% to $0.25 per million tokens with 5.1, which Anthropic estimates cuts agentic workloads by up to 45%
• Strong multi-file planning and broader thinking with better tool use

Best for: production agentic pipelines, multi-day refactors, and any task where a wrong answer costs more than the tokens, once your evals show Opus 5.5 falling short on it. Our Claude Fable 5.1 guide covers this release, and our Claude Fable 5 overview covers the June original.

Trade-off: $10 per million input tokens and $50 per million output tokens is 2.5 times Opus 5.5's rate, and on Anthropic's own table Fable 5.1 now trails Opus 5.5 on SWE-bench Pro, Terminal-Bench 4.0, and CursorBench 4.0. Anthropic says the real-world gap is narrower than those scores suggest, but the burden of proof has flipped. On the older CursorBench 3.2.0, Fable 5.1 at medium effort scored 68.0% for $3.53 per task.

3. GPT-6 Astra (OpenAI)

GPT-6 Astra is OpenAI's frontier model, released on September 3, 2026, and it still sits first on the tbench.ai Terminal-Bench 4.0 agent leaderboard at 58.2% with the Codex harness at max effort, though Opus 5.5 does not have an agent entry there yet.

The model page lists a 1,050,000-token context window, 128,000 output tokens, an April 30, 2026 knowledge cutoff, and effort levels from none through max. Pricing is $10 per million input tokens, $1 for cached input, and $50 per million output tokens.

OpenAI's launch material leans on its own evaluations and its system card rather than the cross-lab benchmarks. Their evaluations are strong, but I would not call Astra a clear winner over Opus 5.5 or Fable 5.1. We cover the launch numbers in our GPT-6 Astra overview.

Key features:

• The Responses API exposes hosted_shell, apply_patch, computer_use, and tool_search, which is the tool set Codex itself runs on.
• Cached input at $1 per million tokens, a tenth of the base price, which matters for agent loops that re-read the same repository.
• Astra is the first OpenAI model to reach the top cybersecurity tier of its Preparedness Framework, so some security-adjacent prompts are gated.

Best for: teams already on Codex, GitHub Copilot, or the Microsoft stack, science- and engineering-heavy tasks, and anyone who needs better third-party tool support. If you want most of the capability for less, GPT-6 Sol, released September 22 at $2 input and $10 output per million tokens, succeeds GPT-5.6 Sol, and with no GPT-6 Terra, it now fills Terra's old price slot. On OpenAI's own charts it scores 68.8% on DeepSWE 1.1 and 49.3% on FrontierCode, though GPT-5.6 Sol at max effort still scores higher on DeepSWE.

Trade-off: Fable-tier pricing, and Opus 5.5 now matches Astra on Terminal-Bench 4.0 for about 40% of the cost per task by Anthropic's count, with Artificial Analysis scoring the two level. Astra's clearest leads are in science-heavy work, at 64.6% on Terminal-Bench-Science and 65.5% on FrontierSWE v2, both ahead of Opus 5.5.

4. Gemini 3.8 Flash (Google)

Gemini 3.8 Flash is Google's workhorse model, released September 2, 2026, and one of the cheapest ways to get a frontier-lab agentic coding score (GPT-6 Luna is cheaper per token, but posts lower agentic scores). Google's evaluation report shows 89.4% on Terminal-Bench 2.1 and 73.7% on DeepSWE v1.1, a 113-task long-horizon suite where Fable 5.1 scored 67.4%. The same table has Opus 5 slightly ahead at 74.0%, Anthropic reports 74.2% for Opus 5.5, and Google's developer guide adds 61.6% on SWE-bench Pro.

Pricing on the Gemini API pricing page is $0.75 per million input tokens and $3.75 per million output tokens through December 31, 2026, then $1.50 and $7.50 from January 1, 2027. Even at the 2027 price, that is just over a third of Opus 5.5's output rate. The context window is 1M input tokens with 64K output.

Key features:

• Native multimodal input, so you can hand it an architecture diagram or a screenshot of a failing UI next to the code.
• Google positions it as the model for high-volume agentic work and prices it accordingly.
• A Cyber variant exists for vulnerability work, gated separately, which we cover in our Gemini 3.8 Flash and Flash Cyber overview.

Best for: high-volume agent loops, cost-sensitive teams, and Vertex AI shops. Gemini 3.1 Pro, released February 19, 2026, remains Google's Pro-tier model with 54.2% SWE-bench Pro at $2 input and $12 output per million tokens, but for coding specifically, I would pick 3.8 Flash over 3.1 Pro today.

Trade-off: 19.1% on Terminal-Bench 4.0. Flash is strong on well-scoped terminal work and weak on frontier science tasks, so keep a stronger model on call for the hardest tickets.

That covers the cloud models. The rest of the list is models you can download.

What Are the Best Open-Weight Coding LLMs in 2026?

The best open-weight coding LLMs in 2026 split into 2 groups: datacenter-scale models like DeepSeek V4.1 Flash and Kimi K3 that match frontier scores but need serious server hardware, and sub-120B models like Qwen3.8-27B and Laguna S 2.1 that you can run on hardware you own.

"Open weight" here means the weights are downloadable. The actual licenses range from MIT and Apache 2.0 to custom terms.

5. DeepSeek V4.1 Flash (DeepSeek)

DeepSeek V4.1 Flash is DeepSeek's September 10, 2026 release, and despite the Flash name it is now the DeepSeek model I would reach for first. DeepSeek says it beats its own V4 Pro 0813 flagship on performance, cost, speed, and task completion time. Vals AI's independent index leans the same way, ranking it the top open-weight model at 57.9%, against the 52.4% Vals recorded for V4 Pro 0813 in August.

It is a 552B-parameter mixture-of-experts (MoE) model with about 8B parameters active per token on input and 16B on output, a 1M-token context, native image input, and MIT-licensed weights. DeepSeek reports 90.6% on Terminal-Bench 2.1 and 74.2% on DeepSWE v1.1, the highest vendor-reported open-weight scores on both. Vals AI's own Terminal-Bench 2.1 run is less generous at 74.5%, second among open-weight models.

We cover the release in more depth in our DeepSeek V4.1 Flash overview.

Key features:

• API pricing on DeepSeek's pricing page is $0.15 per million input tokens and $0.60 per million output tokens off-peak, doubling to $0.30 and $1.20 during weekday peak hours (01:00 to 04:00 and 06:00 to 10:00 UTC). Cache hits cost $0.003 per million off-peak.
• Served as deepseek-flash on an OpenAI-compatible API, so the ask_coding_model.py script later in this article works with a base URL change.
• A KV cache about a quarter the size of V4 Flash's, which is how DeepSeek prices long-context work this low.

Best for: frontier-adjacent terminal coding for pennies, and batch code jobs you can schedule off-peak.

Trade-off: it scores 31.2% on Terminal-Bench 4.0 in DeepSeek's own report, so the hardest long-horizon agent work still belongs to the frontier labs. The checkpoint is also about 510 GB, so "open weights" here means a multi-GPU server. If you are on V4 Pro 0813, DeepSeek announced it would route that model to V4.1 Flash on September 14, then reversed course, and V4 Pro is still served at $0.66/$1.98 off-peak until further notice.

6. Kimi K3 (Moonshot AI)

Kimi K3 is Moonshot AI's 2.8-trillion-parameter open-weight flagship, released in July 2026, and it posts 88.3% on Terminal-Bench 2.1, second among open models behind DeepSeek V4.1 Flash's vendor-reported 90.6%.

The Hugging Face card lists 104B active parameters across 896 experts (16 routed plus 2 shared per token), a 1,048,576-token context, and MXFP4 weights. Vals AI measured 93.4% on SWE-bench Verified.

Key features:

• 1M-token context with native vision.
• Ships under the Kimi K3 License, a custom license rather than MIT or Apache, so read it before commercial use.
• Recommended inference stacks are vLLM, SGLang, and TokenSpeed, and Moonshot calibrated some of its GPU evaluation tasks for H20 GPUs.

Best for: anyone who wants the strongest open agentic coder available.

Trade-off: near-frontier capability comes only at datacenter scale. The 3-point gap to Fable 5.1 on Terminal-Bench 2.1 looks close, but it is not like-for-like: Moonshot measured 88.3% in its own Kimi Code harness, while Fable's 91.4% comes from Artificial Analysis's Terminus 2 runs. In practice, you are renting it through a hosted provider or running your own cluster, plus a custom license to clear with legal first.

7. Qwen3.8-27B (Alibaba)

Qwen3.8-27B is a dense 27-billion-parameter model released in August 2026 under Apache 2.0, and it is the best coding LLM you can run on a single 24 GB GPU.

The model card reports 61.7% on SWE-bench Pro, 73.0% on Terminal-Bench 2.1, 90.3% on LiveCodeBench v6, and 42.2% on DeepSWE 1.1, with a native 262,144-token context extensible to 1M with YaRN. Those SWE-bench Pro and Terminal-Bench numbers beat Laguna S 2.1, a model 4 times its size, and they beat Gemini 3.1 Pro on SWE-bench Pro. Granted, Qwen ran SWE-bench Pro on its own corrected task set, so treat those cross-lab comparisons as directional.

Key features:

• The community UD-Q4_K_M GGUF from Unsloth is a single 16.5 GB file, which leaves room for a 32K context on a 24 GB card. UD-Q4_K_XL is 17.6 GB.
• Dense architecture, so it is slower per token than a 3B-active MoE but far more consistent on multi-file edits.
• Apache 2.0, so no usage restrictions for commercial products.

Best for: developers who cannot send code to an external API, solo practitioners with one RTX-class GPU, and anyone who wants a local-versus-Claude comparison on their own repository before paying for the cloud.

Trade-off: 73.0% versus 91.4% on Terminal-Bench 2.1 is still an 18-point gap, and it shows up as more retries on long agentic tasks.

8. Laguna S 2.1 (Poolside)

Laguna S 2.1 is Poolside's 118B-parameter mixture-of-experts coding model with 8B active parameters, released July 21, 2026, and it is the open-weight pick for a Mac Studio, DGX Spark, or multi-GPU workstation.

Poolside's launch post reports 59.4% on the SWE-bench Pro public set, 70.2% on Terminal-Bench 2.1 with max thinking (60.4% with thinking off), 78.5% on SWE-bench Multilingual, and 40.4% on DeepSWE.

The model was trained on 409,000 environments, including 83,000 terminal tasks and 168,000 software-engineering workflows, on 4,096 H200s in under 9 weeks.

Key features:

• 1M-token context window, unusual at this size.
• OpenMDW-1.1 license, permissive but worth a read for your legal team.
• Thinking mode is on by default and worth about 10 points on Terminal-Bench 2.1; mean completion length ranged from about 23K to 249K tokens per task in Poolside's runs, so budget for it.

Best for: teams that want a Claude Code-style local agent on a 96 to 128 GB unified-memory machine, and repositories large enough to need the 1M window locally.

Trade-off: 118B parameters at 4-bit is roughly 60 to 70 GB of weights before you allocate a KV cache, so a 24 GB GPU is out. On raw scores Qwen3.8-27B edges it, but Laguna's 8B active parameters make it far faster once the weights fit, which is the point of an overnight agent.

9. Qwen3-Coder-Next (Alibaba)

Qwen3-Coder-Next is an 80B-parameter mixture-of-experts model that activates only 3B parameters per token, released February 3, 2026 under Apache 2.0, and it is the fastest capable local coder for hardware that cannot hold a dense 27B model at speed.

The model card reports 70.6% on SWE-bench Verified, 44.3% on SWE-bench Pro, and 36.2% on Terminal-Bench 2.0, with 512 experts (10 active plus 1 shared) and a 262,144-token context. It runs in non-thinking mode only.

Key features:

• The official Q4_K_M GGUF is about 48 GB, which suits a 64 GB Mac or a CPU-offload setup better than a single consumer GPU.
• Hybrid attention (3 Gated DeltaNet layers per standard attention layer) keeps long-context memory use low.
• Supported in vLLM, SGLang, Ollama, LM Studio, MLX-LM, llama.cpp, and KTransformers, per the card.

Best for: long-horizon overnight tasks where tokens per second matter more than peak accuracy, and laptops with 64 GB of unified memory.

Trade-off: 44.3% on SWE-bench Pro is 17 points behind Qwen3.8-27B, so for a single hard bug I would reach for the dense model.

Other open-weight models worth a look

Four more models nearly made the list, and 2 of them will suit specific teams better than my picks:

• DeepSeek V4 Pro 0813 (DeepSeek): 1.6T total, 49B active, 1M context, MIT license, 96.4% on Vals AI's archived SWE-bench Verified. Still served at $0.66 input and $1.98 output per million tokens off-peak, but Vals measured it at 54.7% on Terminal-Bench 2.1 against the 87.9% DeepSeek reports, and DeepSeek now points users to V4.1 Flash. Our DeepSeek V4 explainer covers the architecture.
• Kimi K2.6 (Moonshot): 1T total, 32B active, 256K context, modified MIT license, 80.2% SWE-bench Verified, 58.6% SWE-bench Pro, and 89.6% LiveCodeBench v6. The cleanest license among the trillion-scale models after DeepSeek V4 Pro's plain MIT.
• MiniMax M3: 428B total, 23B active, 1M context, native image and video input, 80.5% SWE-bench Verified and 59% SWE-bench Pro. The open pick if your tasks mix code with screenshots.
• Qwen3.8-Flash-Next: 125B total with 6B active, 62.5% SWE-bench Pro and 58.7% DeepSWE, under the more restrictive qwen-community-1.0 license. Stronger than Qwen3.8-27B on DeepSWE, but the license kept it out of my top 9.

If one of these open-weight picks fits your hardware, the next section shows how to get it running.

How Do You Run an Open-Weight Coding Model Locally?

Running an open-weight coding model locally takes 3 steps: download a quantized checkpoint, serve it behind an OpenAI-compatible endpoint, and point your client or coding assistant at that endpoint. I'll use Qwen3.8-27B in this example because it is the easiest of the 9 to fit on consumer hardware.

First, the download. The huggingface_hub library handles resumable transfers and caching, which helps with these larger files:

"""Download a quantized coding model from Hugging Face.
 
Qwen3.8-27B at UD-Q4_K_M is a single 16.5 GB file, which leaves room for
a 32K context on a 24 GB GPU. Swap FILENAME for the UD-Q4_K_XL build if you
have the extra 1 GB to spare.
"""
 
from huggingface_hub import hf_hub_download
 
REPO_ID = "unsloth/Qwen3.8-27B-GGUF"
FILENAME = "Qwen3.8-27B-UD-Q4_K_M.gguf"
 
 
def fetch(repo_id: str = REPO_ID, filename: str = FILENAME) -> str:
    """Download one file from the Hub and return its local path."""
    path = hf_hub_download(repo_id=repo_id, filename=filename)
    print(f"Saved to {path}")
    return path
 
 
if __name__ == "__main__":
    fetch()

Save that as download_gguf.py and run uv run --with huggingface_hub python download_gguf.py. On Windows you will see a warning about symlinks unless Developer Mode is on.

Second, serve it.

Any of llama.cpp's llama-server, LM Studio, or Ollama will expose an OpenAI-compatible /v1 endpoint. With llama.cpp the command is one line, and 2 flags do the work: -ngl 99 offloads every layer to the GPU and -c 32768 sets a 32K context.

llama-server -m Qwen3.8-27B-UD-Q4_K_M.gguf -c 32768 -ngl 99 --port 8080

Third, the client. I keep one script for every model I evaluate, local or hosted, and switch targets with 3 environment variables. The same file talks to the local server above, to DeepSeek's API, or to OpenAI's:

"""Send one coding prompt to any OpenAI-compatible endpoint.
 
The same script talks to a local llama.cpp or vLLM server, to DeepSeek's
API, or to OpenAI itself. Only three environment variables change:
 
    LLM_BASE_URL   e.g. http://localhost:8080/v1  or  https://api.deepseek.com
    LLM_MODEL      e.g. qwen3.8-27b  or  deepseek-flash
    LLM_API_KEY    anything non-empty for a local server
"""
 
import os
 
from openai import OpenAI
 
PROMPT = (
    "Write a Python function top_n(df, col, n) that returns the n largest "
    "rows of a pandas DataFrame by column col, with a docstring and a "
    "ValueError if col is missing."
)
 
 
def ask(prompt: str = PROMPT) -> str:
    """Return the model's reply for a single-turn coding request."""
    client = OpenAI(
        base_url=os.environ["LLM_BASE_URL"],
        api_key=os.environ.get("LLM_API_KEY", "local"),
    )
    response = client.chat.completions.create(
        model=os.environ["LLM_MODEL"],
        messages=[{"role": "user", "content": prompt}],
        temperature=0.2,  # keep code generation close to deterministic
    )
    return response.choices[0].message.content
 
 
if __name__ == "__main__":
    print(ask())

Save it as ask_coding_model.py and run it with LLM_BASE_URL=http://localhost:8080/v1 LLM_MODEL=qwen3.8-27b uv run --with openai python ask_coding_model.py.

If you go on to wire several of these endpoints into an application with routing, retries, and tool calls, our course on developing LLM applications with LangChain covers the abstractions that stop this from becoming a pile of if statements.

How Should You Choose the Best LLM for Coding?

Choosing the best LLM for coding comes down to 4 constraints: whether your code can leave your machine, how much memory you have, what you will pay per million output tokens, and how much context a single task needs. The table below puts the 9 ranked models side by side on the numbers I trust most, and the decision guide after it maps those constraints to a pick.

The decision guide

Here is how I map the 4 constraints onto the rankings:

• Agentic coding pipelines where correctness dominates cost: Claude Opus 5.5 at high or xhigh effort, with Fable 5.1 on call for long-horizon tasks where your evals show Opus 5.5 falling short.
• Daily AI-assisted coding at a sane price: Claude Opus 5.5 at its default medium effort first, GPT-6 Sol second if you live in Codex.
• Frontier science, simulation, or GPU-kernel work: GPT-6 Astra or Claude Opus 5.5. Astra leads on Terminal-Bench-Science, Opus 5.5 on Terminal-Bench 4.0.
• Massive codebase, 1M-token prompts, tight budget: Gemini 3.8 Flash for the price, Opus 5.5 when Flash's answers get sloppy.
• Open weights via API: DeepSeek V4.1 Flash off-peak.
• Local and private on a single 24 GB GPU: Qwen3.8-27B at UD-Q4_K_M.
• Local and private on a 96 to 128 GB machine: Laguna S 2.1, or Kimi K3 if "machine" means "cluster."
• Local and fast on a 64 GB laptop: Qwen3-Coder-Next.

If you want a more general framework for matching a model to an application, including hosting options and licensing, our guide on how to select the best LLM for your application goes wider than coding.

And whichever model you pick, the skills that get value out of it are the same: our AI for Software Engineering skill track and our course on AI-assisted coding for developers teach the prompting, testing, and review habits that turn a 91% benchmark into a merged pull request.

Final Thoughts

Claude Opus 5.5 is the best coding LLM in September 2026 and, unusually, also the one to put on your team's bill. Claude Fable 5.1 is the escalation path for the longest tasks, and Qwen3.8-27B is the open-weight model that turns a 24 GB GPU into a private coding assistant that beats last year's frontier on SWE-bench Pro. Everything else is a question of your constraints, and the decision guide above is how I would resolve them.

The bigger shift is that the benchmark that defined this category for 2 years, SWE-bench Verified, stopped mattering in the same 12 months that open weights caught up on it.

That is not a coincidence.

When Opus 5 and DeepSeek V4 Pro sit 0.6 points apart on a saturated test, and a $20-per-million model now beats Anthropic's own $50 one on SWE-bench Pro, the value has moved to harness design, effort budgets, and evaluation on your own repository, which is exactly the work a vendor table cannot do for you.

So do that work. Take the ask_coding_model.py script, point it at 2 or 3 of these models, run it against 20 real tickets from your backlog at the effort level you will actually pay for, and let that result overrule anything I wrote here. If vibe coding is more your speed than evaluation harnesses, our piece on what vibe coding is and where it breaks is an honest look at the trade-offs, and the same model rankings apply.