Best open source LLM for coding: Kimi K2.6 leads at 80.2% on SWE-bench Verified

Kimi K2.6 posts the highest reported SWE-bench Verified score in this comparison, 80.2%, against GLM-4.7 at 73.8% and Qwen3.6-35B-A3B at 73.4%, per vendor figures published through August 2026.

Its license adds only a branding clause below 100 million monthly users.

GLM-4.7 and Qwen3-Coder-480B-A35B carry fewer conditions than that.

Table note: rows sort by SWE-bench Verified first, since that is this comparison's primary axis; the five vendors who publish it appear at the top in descending order. The eight rows below them do not publish SWE-bench Verified at all, so they sit outside that ranking rather than ranked last by omission, ordered instead by Terminal-Bench where a vendor reports one. NR means the vendor has not published a score on that benchmark for that checkpoint. † means the figure is not stated on the cited model card. Terminal-Bench 2.0 and 2.1 are different test versions and do not sort onto one scale; the version split stays visible next to each score for that reason. Self-host floor figures marked "vendor-stated" come from the model's own release material; figures marked "community" come from third-party quantized builds, not the model owner.

Four numbers carry the whole table. Kimi K2.6 leads the SWE-bench Verified group at 80.2%, 6.4 points ahead of GLM-4.7 in second place.

Kimi K3 and GLM-5.3 both clear 88 on Terminal-Bench 2.1 in the lower group, one point apart, which the interval treats as a tie rather than a win.

DeepSeek-V4-Flash reaches 82.7 on that same 2.1 harness while running roughly a fifth of the active parameters carried by Kimi K3, the strongest capability-per-active-parameter result in the set.

gpt-oss-120b runs on one 80GB GPU by OpenAI's own account, the only flagship-class entry in this table a single card can hold.

Basis and method

Every figure in this article is Basis 2. Aggregated, not measured: vendor model cards, vendor pricing pages, GPU rental pricing pages, and coding-agent documentation, not a test run of ours. LLM Waves Research collected these figures between August 26 and September 1, 2026, UTC, and normalized them into one comparable table. No claim below states or implies that we ran these models ourselves.

Every model card, license file, and pricing page cited carries its own retrieval date in the raw data file and on the methodology page. Cost figures are our own arithmetic, built from vendor-published GPU hourly rates and vendor-published token prices, with the formula shown in the cost section below. Full sourcing sits on the methodology page, version 1.0.

Decision axes: this comparison ranks reported coding-benchmark scores where a vendor publishes them, then separates that ranking from three things a benchmark score cannot tell a reader: whether a coding agent can actually reach the model, what self-hosting it costs at real volume, and what license obligation kicks in once a team scales past a stated revenue or user threshold. The living version of this ranking sits on LLM Waves' open-weight models leaderboard, updated as new checkpoints ship.

Before any of that, one caution about the scores themselves: half of this roster reports Terminal-Bench under a version the other half does not use, and the chart below is the fastest way to see which half is which.

The five highest bars all belong to Terminal-Bench 2.1, and the four lowest all belong to Terminal-Bench 2.0; no model in this roster has published a score on both versions, so nothing here confirms whether the newer harness is simply easier or whether those models are simply stronger.

Which coding agent actually works with which open-weight model

A coding agent cannot act on a model it cannot reach, so agent compatibility gates every other number in this article. Four agents dominate developer search for this pairing: Claude Code, Cline, Cursor, and Continue.

They do not treat open-weight models the same way. Continue and Cline both document native support for custom OpenAI-compatible endpoints, local runtimes, and named open-weight providers.

Cursor's own documentation lists five providers for bring-your-own-key chat models: OpenAI, Anthropic, Google, Azure OpenAI, and AWS Bedrock. None are open-weight hosts.

Claude Code has no first-party open-weight setting at all; developers route third-party models into it by pointing the ANTHROPIC_BASE_URL environment variable at a translation proxy such as LiteLLM, a workaround documented by the proxy project rather than by Anthropic.

The chart below turns that into a grid. Read it before picking a model, not after, since a strong benchmark score is irrelevant inside a workflow that cannot call the model.

Cline and Continue reach open-weight models through native configuration; Cursor reaches none of them through any documented path, and Claude Code reaches them only through a proxy Anthropic does not maintain.

Continue's own provider documentation names DeepSeek and Mistral as dedicated providers alongside Ollama, LM Studio, and llama.cpp for fully local runs.

Cline's provider documentation names Fireworks, Together, and Moonshot by name, and Cline's own GitHub issue tracker shows active maintenance of GLM, Kimi, and DeepSeek model identifiers for its Fireworks integration.

A developer standardized on Cursor cannot point it at Qwen3-Coder, GLM-4.7, or Kimi K2.6 through any setting Cursor documents today.

Self-hosted vs API: the real break-even math

Self-hosting is not automatically cheaper. It only saves money past a specific token volume, and that volume depends entirely on which model and which API price it is being compared against.

We built four pairings from vendor-published GPU rental rates and vendor-published API prices: a 24/7 GPU rental converted to a monthly cost, divided by the blended per-million-token price of the comparable hosted option, assuming a 30% input and 70% output token mix typical of agentic coding sessions.

That is the whole formula; no throughput assumption is required because both sides are priced in dollars per month.

Renting one RTX 4090 around the clock through RunPod's Secure Cloud tier costs $540 a month at $0.74 an hour. Against Alibaba's Qwen3-Coder-Plus entry pricing of $1 per million input tokens and $5 per million output tokens, that GPU pays for itself past 142 million tokens a month, a volume a single active developer can plausibly cross.

Against Z.ai's GLM-4.7-Flash, which Z.ai prices at $0 for input and output, the same GPU never breaks even, at any volume, because there is no per-token cost to beat.

Two GPUs of A100 80GB class running Qwen3-Coder-480B-A35B cost $2,321 a month and need 2.94 billion tokens a month to beat DeepInfra's Turbo-tier hosted price for the same weights, one concrete case of why the same model performs differently across providers depending on who hosts it.

Four H100s running DeepSeek-V4-Flash cost $9,607 a month and need 18.2 billion tokens to beat DeepSeek's own off-peak API rate.

Self-hosting rewards teams with either very high, predictable volume or a specific reason to avoid sending code off-premises, and it punishes anyone comparing against a vendor's free or steeply discounted tier.

What self-hosting actually needs in VRAM

A model's advertised size and its self-hosting cost are not the same number, because almost nobody runs the full-precision release.

Unsloth's own guide to Qwen3-Coder puts the small Qwen3-Coder-30B-A3B variant at 18GB of unified memory for a usable quantized build, small enough for one RTX 4090, while the 480B-A35B flagship needs 150GB or more even at aggressive quantization, a multi-GPU proposition regardless of which cloud rents the hardware.

gpt-oss-120b is the outlier here: OpenAI states it "runs efficiently on a single 80GB GPU" by design, and the 20B sibling fits inside 16GB, the only pairing in this roster the vendor itself sized for a single consumer-adjacent card.

The benchmark number is not what you will run

None of the vendors in this comparison publish a second score for the quantized build most self-hosters actually deploy. The 73.8% SWE-bench Verified figure for GLM-4.7 and the 80.2% figure for Kimi K2.6 both describe the released weights at whatever precision the vendor tested, most often FP8 or BF16, not the 4-bit or 2-bit GGUF a developer downloads to fit a single GPU.

A 671B-class dense-equivalent model shrinks from roughly 1.34TB at BF16 to 256GB at a 2-bit dynamic quantization in community builds, a reduction of more than 80%, and no vendor card in this comparison states how much of the benchmarked score survives that cut.

That gap is filled today by community testing on forums and quantization-specific leaderboards, not by the model owners, and it means every benchmark number in the table above should be read as a ceiling on what a quantized, self-hosted deployment will produce, not a floor.

License divergence: open-weight vs open source, and what you can ship

"Open source" and "open-weight" are not interchangeable. The difference decides what a company can legally ship. The Open Source Initiative's Open Source AI Definition, version 1.0, requires a system to publish enough training-data information for a skilled person to substantially reproduce it, the complete code used to train and run it, and the model parameters themselves.

Nearly every model in this article publishes only the third item, the parameters. That makes them open-weight, a narrower claim than open source, and by the OSI's own account, Meta's Llama license fails the definition for restricting fields of use and discriminating among users, not for withholding weights.

Four models in this roster carry no threshold at all: Qwen3-Coder under Apache 2.0, DeepSeek-V4 under MIT, and GLM-4.7 and GLM-5.3-Flash under MIT.

Three carry a scale-gated clause: Kimi K2.6 requires a branding display above $20 million in monthly revenue, Kimi K3 requires a separate commercial agreement above $20 million in trailing-12-month revenue from a model-as-a-service business, and a text-only build of Qwen3.8-Max requires a commercial license above $50 million over the same window.

GLM-5.3 stands apart at the top of the chart: any operator with more than $10 billion in trailing-12-month revenue must pass a Z.ai security review before commercial use, a clause aimed squarely at hyperscalers rather than ordinary startups.

The predecessor to GLM-5.3, GLM-5.2, shipped under plain MIT, so this is a real tightening between two consecutive releases from the same vendor, not a rounding difference.

GLM: MIT by default, one flagship exception

Z.ai ships most of its GLM family under MIT, the least restrictive license in this table. GLM-4.7, released in December 2025, reports 73.8% on SWE-bench Verified and 66.7% on SWE-bench Multilingual, the only vendor in this comparison to publish a multilingual coding figure at all.

GLM-4.7-Flash costs nothing to call through Z.ai's own API, input and output both priced at $0. GLM-5.3, released in August 2026, breaks the pattern: its weights carry the custom license described above rather than MIT, while its Flash sibling, GLM-5.3-Flash, kept MIT.

DeepSeek: the widest context window in the roster, MIT throughout

DeepSeek's entire V4 line ships under MIT with no exceptions. Both DeepSeek-V4-Pro and DeepSeek-V4-Flash advertise a 1,048,576-token context window, the largest confirmed figure in this comparison alongside Kimi K3. DeepSeek-V4-Pro runs 1.6 trillion total parameters with 49 billion active, and reports 87.9 on Terminal-Bench 2.1.

DeepSeek does not publish SWE-bench Verified for either V4 checkpoint, reporting a proprietary suite instead, which is why the table above leaves that cell blank rather than filling it with a number DeepSeek never stated.

A third-party host running the identical weights can still score differently from DeepSeek's own endpoint, for reasons covered in why the same model performs differently across providers.

Context windows are where the roster splits hardest. The chart below lines up every advertised maximum on one log scale.

Four checkpoints clear a million tokens: Kimi K3, both DeepSeek-V4 variants, and GLM-5.3. Qwen3-32B sits at the opposite end with 32,768 tokens, a roughly thirty-two-fold gap between the widest and narrowest window in this comparison, and a wider advertised window never by itself proves a model uses that space well.

Qwen: the only fully unrestricted flagship-scale coder

Qwen3-Coder-480B-A35B-Instruct ships under Apache 2.0 with no revenue gate, no branding clause, and no field-of-use restriction, making it the only model in this table at flagship scale with a fully unrestricted license.

Alibaba's own launch material states a top result among open models on SWE-bench Verified without publishing the exact figure, an omission not papered over here with a borrowed number.

Qwen3.6-35B-A3B, a newer and much smaller release, reports 73.4% on SWE-bench Verified at 3 billion active parameters, within half a point of GLM-4.7 at roughly a tenth of the active-parameter cost.

Kimi: the highest reported score, and the steepest license curve

Moonshot AI's Kimi line reports the two highest SWE-bench Verified figures in this comparison and the two most restrictive licenses of the group.

Kimi K2.6 posts 80.2% at 32 billion active parameters, under a modified MIT license that adds only a branding requirement at very large scale.

Kimi K3, the newer flagship, posts 88.3 on Terminal-Bench 2.1 and pairs it with 1,048,576 tokens of context, but its license adds a mandatory commercial agreement above $20 million in trailing-12-month revenue from a model-as-a-service business, and Moonshot's own release material recommends deployment on "supernode configurations with 64 or more accelerators," ruling out casual self-hosting entirely.

gpt-oss: the non-Chinese pick, and the only single-GPU flagship

Every other lab named in this article is based in China. OpenAI's gpt-oss-120b and gpt-oss-20b are the answer for a reader who specifically wants a non-Chinese open-weight option, both under Apache 2.0. gpt-oss-120b reports 16.2% on SWE-bench Pro, the lowest coding figure in this roster on that particular benchmark, and it is also the only flagship-class model here OpenAI itself sized to run on a single 80GB GPU. gpt-oss-20b fits in 16GB, a genuine on-device option rather than a marketing claim about one.

What we did not measure

We ran none of these models ourselves, so this comparison carries no latency, throughput, or accuracy figures beyond what each vendor published, and it does not adjudicate between vendors' differing benchmark harnesses beyond noting where they diverge. Fine-tuning cost, multi-agent orchestration overhead, and non-coding capability sit outside its scope. Quantized-build accuracy loss is discussed qualitatively above because no vendor publishes a quantized score to cite as a number.

Which model fits which situation

No single model wins every axis. Eight reader situations, eight different answers, each with its own number.

For developers building day to day: GLM-4.7 balances a clean MIT license with a 73.8% SWE-bench Verified figure and real support in Cline and Continue.

For startups watching every dollar: GLM-4.7-Flash costs $0 to call through Z.ai's own API, the only model in this roster with that property.

For enterprise buyers who need legal clarity at scale: Qwen3-Coder-480B-A35B carries the fewest license conditions of any flagship-class model here, a material advantage once legal review enters the picture.

For high-volume workloads: DeepSeek-V4-Flash on a rented multi-GPU node crosses its own break-even point past 18.2 billion tokens a month, a threshold only sustained high-volume users will clear.

For low-latency needs: Qwen3.6-35B-A3B activates only 3 billion parameters per token, the lightest compute path to a 73%-class SWE-bench Verified score in this table.

For on-device use: gpt-oss-20b fits inside 16GB of memory by OpenAI's own specification, the clearest single-card, single-user option here.

For teams committed to self-hosting: Qwen3-Coder-30B-A3B needs roughly 18GB of quantized memory per Unsloth's own guide, cheap enough that its break-even point against a mid-tier API arrives inside three months of typical use.

For non-English codebases: GLM-4.7 is the only model here that reports a dedicated multilingual coding score, 66.7% on SWE-bench Multilingual, rather than leaving multilingual performance unstated.

Which open source LLM is best for coding right now

Kimi K2.6 reports the highest SWE-bench Verified score in this comparison, 80.2%, under a license that adds only a branding condition below $20 million in monthly revenue.

GLM-4.7 is the closer pick for a team that wants a clean MIT license without that condition attached at any revenue level.

Are open-source coding models actually as good as Claude or GPT-5 for real work

We did not test that question directly and will not claim a cross-vendor verdict we cannot support with our own measurement.

What we can state is that GLM-4.7, Kimi K2.6, and DeepSeek-V4-Pro each report scores on at least one recognized coding benchmark within the range vendors of closed proprietary models report for themselves, which narrows the gap on paper more than casual skepticism usually allows, without closing it on evidence gathered firsthand here.

Which tool should you use to run these models locally

Ollama and LM Studio target ease of setup, both wrapping llama.cpp with a simpler interface for a single machine.

vLLM and SGLang target production throughput and multi-GPU serving, the tools named directly in the deployment examples published for GLM-4.7 and DeepSeek-V4.

A developer testing one model on a laptop reaches for Ollama; a team serving a self-hosted coding agent to a whole engineering org reaches for vLLM.

What's the best small open source model for a single consumer GPU

gpt-oss-20b is the cleanest answer: OpenAI states it runs inside 16GB of memory, and that figure comes from the vendor rather than a community estimate.

Qwen3-Coder-30B-A3B is the next best documented option, at roughly 18GB quantized per Unsloth's published guide, both fitting comfortably on a single high-end consumer card.

Is a model labeled open source actually open source, or just open-weight

Almost every model in this article is open-weight, not open source under the OSI's Open Source AI Definition, because vendors publish parameters without the training-data information and training code the definition also requires.

Apache 2.0 and MIT govern how the published weights may be used; they say nothing about whether the underlying training pipeline was ever disclosed, and none of the vendors in this comparison disclosed it.

Are the benchmark scores these models get actually trustworthy

Each score in this article's table came from the model vendor's own card or blog post, not from an independent test this article ran, and that is stated plainly rather than implied.

Terminal-Bench 2.0 and 2.1 scores are not comparable to each other, a distinction several vendors' own marketing pages elide by showing only their own number without the version label attached.

What we are watching next

Twelve checkpoints sit in this roster today, and the roster will shift within weeks of publication; four of them shipped in the six weeks before this page went live.

The promised full weight release for Kimi K3, the eventual official pricing for GLM-5.3, and any quantized benchmark a vendor chooses to publish are the three most likely sources of the next dated correction to this page.

The live comparison updates as those land, not this snapshot.