Best Open-Weight LLMs 2026: DeepSeek vs Qwen vs Kimi vs GLM vs Llama

The best open-weight LLM depends on what you can run and what your license permits. DeepSeek V4 is the cost-efficient general and coding contender, Qwen offers the broadest range of deployable sizes, Kimi K3 targets very long multimodal agent work, GLM-5.2 targets long-horizon reasoning and coding, and Llama 4 has the deepest Western ecosystem but the most consequential EU license caveat.

The catch is that "open weight" is not one decision. DeepSeek, Qwen, Kimi, GLM, and Llama differ on license, context window, coding versus reasoning strength, and whether you can legally run them where your data lives. Pick on a benchmark headline and you can land on a model that fails your task, or one you are not allowed to deploy. This is the head-to-head we run before we commit a model in production, and the order we weigh the trade-offs.

Engineering perspective, not a vendor pitch. We re-checked the official model cards, repositories, and licenses on 7 August 2026. Hosted prices change too quickly to decide a self-hosting shortlist, so the comparison starts with weights, active parameters, context, license, and practical hardware. Benchmark claims remain hypotheses until they pass your eval.

What actually separates the open-weight families in 2026?

They are not five versions of the same model. Each family made a different bet, and that bet decides where it fits in your stack.

• DeepSeek V4. The efficiency bet. V4 Pro has 1.6 trillion total and 49 billion active parameters; V4 Flash cuts that to 284 billion total and 13 billion active. Both advertise a 1M-token context and MIT-licensed weights.
• Qwen (Alibaba). The range bet. The Qwen3.5 and Qwen3.6 families span compact dense and mixture-of-experts checkpoints through large multimodal models. Many named open checkpoints use Apache 2.0, but hosted Max products and some releases have different terms. Check the exact model card, not the family brand.
• Kimi K3 (Moonshot). The scale and agent-memory bet. Kimi K3 has 2.8 trillion total and 104 billion active parameters, a 1M-token context, and native vision. Its weights use a custom Kimi K3 license and require roughly 1.6 TB of storage, so "open weight" does not mean easy to self-host.
• GLM-5.2 (Z.ai). The long-horizon coding bet. The current flagship is roughly 753 billion parameters with a 1M-token context and MIT-licensed weights. It is built for agentic reasoning, but practical deployment still means a serious multi-GPU system.
• Llama (Meta). The Western open-weight incumbent. Huge context windows and a deep tooling ecosystem, but a custom community license, not a true open-source one, and the license terms have restricted EU use. That restriction is the single most important line item for an EU team.

The pattern: the Chinese families compete on price and, increasingly, on coding quality. Llama competes on ecosystem and context length but carries license baggage that hits EU teams hardest.

Germany's Soofi S sits in a different category: a sovereign German-English project that was still in closed beta when we reviewed it. Our Soofi S buyer's review separates its stated release plan from what a buyer can verify today.

Kimi K3 now deserves a separate procurement decision from the older K2 family. Our Kimi K3 API review for EU companies covers its live price, independent performance, Singapore data location, public contract gaps, migration constraints and a measured two-week pilot. This page continues to own the wider family comparison.

How do they compare on size, context, license, and hardware?

This table uses representative current open checkpoints, not hosted products that happen to share the same family name. Context claims come from vendor model cards and still need workload-specific quality tests at long lengths.

Two things jump out. First, architecture efficiency and deployability matter more than the biggest total-parameter number. Second, license is not a footnote. MIT and Apache 2.0 checkpoints are generally simpler for commercial self-hosting, while Kimi K3 and Llama 4 require a model-specific legal review. For an EU company, Llama 4's multimodal-rights restriction can end the evaluation before GPU cost enters the discussion.

Coding or reasoning: which family wins which job?

There is no single winner, because coding and reasoning reward different things. The honest read of the 2026 benchmarks, with the usual caveat that benchmarks lag reality by months:

• Long-horizon coding agents. GLM-5.2 and Kimi K3 are designed for long tool-using workflows, while DeepSeek V4 Pro is the more infrastructure-efficient candidate to test beside them. If your product is an agent that edits code over many steps, compare completed-task rate and recovery behavior, not one-shot coding scores.
• General reasoning and breadth. DeepSeek's pro tiers and Qwen's flagship cover the widest range of tasks well. DeepSeek in particular lands near-frontier reasoning scores at a price that makes it the default for cost-sensitive general work.
• Raw coding accuracy on isolated tasks. The top open-weight scores on SWE-bench-style suites now sit within single-digit percentage points of the leading Western frontier models. The gap that mattered two years ago has mostly closed for everyday engineering work.
• The hardest reasoning still tilts Western. On the very hardest reasoning and the deepest agent loops, the top Claude and GPT tiers still lead. When a wrong answer is expensive, the frontier model can still win on total cost once you count the developer time spent fixing bad output. We covered that trade-off in how to cut LLM token costs in 2026.

"The benchmark headline tells you which model to test first. Your own eval tells you which one to ship. Those are not the same model often enough that you have to run the eval."

Can you self-host these in the EU without a compliance headache?

This is where the families separate hardest for a European team, and where license matters more than benchmarks.

• DeepSeek and GLM. MIT-licensed weights are the cleanest legal starting point in this group. The operational problem remains substantial: GPU capacity, inference software, observability, and evals.
• Kimi K3. The weights are available, but the custom license and roughly 1.6 TB footprint require separate legal and infrastructure reviews. A hosted Kimi API is a different data-residency decision from running K3 inside the EU.
• Qwen open tiers. Apache 2.0 is the most permissive option in the table and self-hosts cleanly. The flagship Max tier, though, is hosted-only and runs outside the EU, so a self-host plan that assumes "Qwen" without naming the tier can quietly route data abroad.
• Llama. The custom community license has restricted EU use, which is a legal question, not a technical one. Resolve the license posture before you build on it, regardless of how good the context window looks.

The deeper point: self-hosting a Chinese open-weight model on EU infrastructure is the move that gives you both the price and the data-residency story. Running the same model through a non-EU hosted API gives you the price but hands you a compliance question to answer first. Which path fits depends on your data classification and your appetite to run inference in-house. If your team is standing up that internal AI capability for the first time, that is exactly the ground our AI enablement work covers. Either way, where the inference runs and where the data lands is a decision to make on purpose, not by default.

So which one should you actually pick?

Pick on the constraint that is hardest to change, not on the headline. The order we work through it:

1. License and jurisdiction first. If you are an EU team that needs to self-host, the Llama EU restriction likely rules it out, and you are choosing among DeepSeek, GLM, Kimi, and the Qwen open tiers. Settle this before you benchmark anything.
2. Match the family to the job. Long-horizon agent: test GLM-5.2, Kimi K3, and DeepSeek V4 Pro. Cost-sensitive general workload at volume: start with DeepSeek V4 Flash. Broad needs across hardware sizes: shortlist named Qwen open checkpoints. Very long context inside the Western ecosystem: consider Llama 4 only after resolving the license.
3. Right-size the tier. Most traffic does not need the flagship. A cheap default with escalation to a stronger tier, the routing pattern, usually beats running the biggest model on everything.
4. Run your own eval before you swap. A benchmark is a starting hypothesis, not a deployment decision. Build a small eval harness on your actual tasks and prove the model holds quality before it touches production. A cheaper model that fails 1 in 10 of your tasks is not cheaper.
5. Re-check every few months. These families ship new versions and new prices on a cadence measured in months. The right pick today is a snapshot, not a permanent answer.

We run this exact sequence in production AI work, including engagements like Twinsoft AI, where the discipline that makes a model swap safe is the eval harness, not the benchmark table.

What about the eval harness everyone skips?

Every recommendation above rests on one thing teams routinely skip: an eval harness built on your own tasks. Public benchmarks are contaminated, gamed, and months behind, and they measure tasks that are not yours. The model that tops a leaderboard can still be the wrong choice for your data, your prompts, and your edge cases.

The harness does not need to be elaborate. A few dozen representative tasks with a clear pass condition, run against each candidate model, tells you more than any leaderboard. It is also the only way to swap models safely later, because it tells you in minutes whether a cheaper or newer model held the quality bar. Without it, every model change is a guess, and a guess that quietly drops quality is the most expensive mistake in this whole landscape.