Open-Weight LLM Showdown 2026: DeepSeek vs Qwen vs Kimi vs GLM vs Llama

A year ago, picking an LLM meant picking a Western frontier API and arguing about which one. That argument is over. Open-weight families, most of them out of China, have closed most of the real-world coding and reasoning gap, at a fraction of the per-token price, and several now ship under licenses you can actually self-host on EU infrastructure. The landscape moved, and the cost lever moved with it.

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. The price and benchmark points below are directional, drawn from public 2026 pricing trends, not vendor-specific quotes. These families version fast, so re-check before you commit. Reference points come from Wavect's AI product work.

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. The price-disruptor. MIT-licensed weights, strong general reasoning and coding, and per-token prices that anchored the bottom of the market. The flash tiers are the cheapest credible option for high-volume work, the pro tiers reach near-frontier coding scores.
• Qwen (Alibaba). The broadest family. Many sizes from tiny to flagship, most of the smaller open tiers under Apache 2.0, which is the most permissive license here. The hosted Max tier is the strongest but is not open-weight, so do not assume the whole family self-hosts.
• Kimi K2 (Moonshot). The agentic-coding specialist. A large mixture-of-experts model under a modified MIT license, tuned for tool use and long coding loops rather than raw chat. Output tokens are pricier here, which matters for agents that generate a lot.
• GLM (Zhipu / Z.ai). The coding-first flagship. MIT-licensed open weights, a long context window, and coding benchmark standings that trade blows with the Western frontier on long-horizon software tasks at a fraction of the cost.
• 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.

How do they compare on price, context, and license?

One table, normalised per 1M tokens for the comparable tiers. Treat every number as a directional snapshot of public 2026 trends, not a vendor quote, and re-check before you commit. Model versions in these families change every few months, so the tier names matter more than any single figure.

Two things jump out. First, the Chinese families sit roughly 10 to 30 times below the top Western frontier tiers on a per-token basis, which is why they reset the cost math for high-volume products. Second, license is not a footnote. MIT and Apache 2.0 let you self-host and ship inside a proprietary product without a royalty conversation. A custom community license with usage carve-outs does not, and for an EU team the Llama EU restriction can take it off the table before price ever 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 and Kimi K2 are the two built for this. GLM's flagship trades blows with the Western frontier on long software-engineering benchmarks, and Kimi is tuned specifically for tool use and multi-step coding loops. If your product is an agent that edits code over many steps, start here.
• 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, GLM, Kimi. MIT and modified-MIT weights mean you can download them and run inference on EU infrastructure. The data never leaves your jurisdiction, and you keep the price advantage. The catch is not the license, it is the operational weight: GPU capacity, an inference stack, and the eval discipline to know the model still performs.
• 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 coding agent: GLM or Kimi K2. Cost-sensitive general workload at volume: DeepSeek flash class. Broad needs with permissive self-host: Qwen open tiers. Very long context inside the Western ecosystem with the license resolved: Llama.
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.