A model trained for a few million dollars matched a frontier reasoning system on graduate-level math benchmarks. It shipped under a permissive license, free to download, free to modify, free to run on a rented GPU or a beefy laptop. That was the story that shook markets in early 2025, and by the middle of 2026 it has stopped being a novelty. Open-weight labs in China and elsewhere now release models every few weeks that land within a few benchmark points of the best proprietary systems from Anthropic, OpenAI, and Google.
And yet closed models still account for roughly 80 percent of token usage worldwide, according to research from MIT Sloan’s Frank Nagle and Georgia Tech’s Daniel Yue. Their study found open models reach about 90 percent of closed-model performance at launch and often close that remaining gap within months, while running at a fraction of the cost. Anthropic’s own economic data shows coding tasks dominate real-world API usage, and coding is precisely the area where open models have made their biggest leap. So the paradox holds: the performance gap has nearly disappeared, the price gap has widened in open source’s favor, and most paying customers keep paying anyway.
This piece looks at where open source LLMs actually stand in the middle of 2026, what people and companies are using them for, and why, despite all the progress, a large share of the market still reaches for a credit card instead of a download link.
The State of Open-Weight Models Right Now
The open-weight landscape looks almost unrecognizable compared to two years ago. Meta’s Llama series, once the default reference point for “open” AI, now shares the spotlight with a crowded field of Chinese labs: DeepSeek, Alibaba’s Qwen, Moonshot AI’s Kimi, and Zhipu AI’s GLM, plus Google’s Gemma and Microsoft’s Phi. Each of these families has released multiple generations in the past year alone, and the release cadence keeps shrinking. Models that were state of the art in January 2026 were often superseded by June.
DeepSeek remains the name most people recognize, largely because of the shock its R1 model caused when it matched OpenAI’s o1 on many benchmarks at a training cost reported around $5.9 million, a number small enough to wipe roughly $589 billion off Nvidia’s market value in a single trading day. The DeepSeek line has kept moving since then. DeepSeek V4 Pro, a mixture-of-experts model with 1.6 trillion total parameters and 49 billion active per token, now targets long-context reasoning, coding, and agentic workflows, with a million-token context window and a hybrid attention design meant to keep that context affordable to serve.
Alibaba’s Qwen family has arguably become the most versatile open option on the market. Qwen3 235B-A22B ships under a clean Apache 2.0 license, and the newer Qwen3.5 397B-A17B pushes further into multimodal reasoning, text, images, video, and documents handled inside one unified model rather than a vision module bolted onto a text backbone. On raw reasoning benchmarks, Qwen 3 has posted some of the strongest open scores around, leading on GPQA Diamond and AIME among open-weight models.
Zhipu AI’s GLM series has quietly become one of the sharpest coding options anywhere, open or closed. GLM-5.2, a 754-billion-parameter mixture-of-experts model with 40 billion active parameters, leads on software-engineering benchmarks like SWE-Bench Pro and Terminal-Bench, with some reports putting its scores ahead of GPT-5.5 and Claude Opus 4.8 on specific coding tasks. It ships under MIT, which means no royalties and few restrictions on commercial use.
Then there’s Kimi K2.6 from Moonshot AI, tuned specifically for long-horizon coding and autonomous task orchestration, and Meta’s Llama 4, which brought a genuinely enormous context window, up to 10 million tokens in the Scout variant, into the open-weight world for the first time. Mistral, the European entrant, has also shifted its licensing posture; both Mistral Large 3 and Mistral Small 4 now ship under Apache 2.0, a real change from the company’s earlier, more restrictive terms.
Licensing, it turns out, is where things get complicated, and it’s worth pausing on that before going further. “Open source” gets used loosely across the industry, and a lot of what gets called open source doesn’t meet the Open Source Initiative’s actual definition, mainly because training data and full training pipelines are rarely released alongside the weights. What most of these releases really offer is “open weights”: you can download the trained parameters, run them, fine-tune them, and in most cases deploy them commercially, but you can’t fully audit or reproduce how the model was built. Some licenses matter more than others in practice. Llama’s community license caps usage at 700 million monthly active users and carries EU-specific restrictions that affect larger operations. Apache 2.0 (Qwen, Gemma, Devstral, Mistral) and MIT (DeepSeek, GLM, Kimi) are the two licenses treated as safest for unrestricted commercial deployment, and most serious enterprise evaluations start by checking which of the two a candidate model actually uses.
Where People Are Actually Using These Models
Benchmark charts are one thing. The more interesting question is what open models get used for once they leave the leaderboard and enter a real product, and the honest answer is: almost everywhere, though unevenly.
Coding and agentic software engineering is the single biggest use case, and it’s not close. SWE-bench Verified, a benchmark built from real GitHub issues rather than synthetic problems, has become the reference point everyone quotes, and open coders now clear 70 to 80 percent on it, within a few points of the best closed systems. Qwen3-Coder’s 480B flagship is described by multiple sources as open state-of-the-art, and its smaller 80B-A3B variant trims that down to a single-workstation footprint while retaining around 96 percent of the larger model’s quality. A common production pattern has emerged around this: run a smaller, cheap local model like Qwen3-Coder 80B-A3B for the routine 95 percent of repo-level tasks (autocomplete, code review, boilerplate, bug fixes) and route only the genuinely hard 5 percent to a frontier API like GLM-5.2 or DeepSeek V4.1-Pro. Paying per token only for what actually needs the frontier model beats buying and running a 400GB rig that sits idle most of the time.
Agentic AI more broadly, models that plan, call tools, read and write files, check their own output, and recover from failed steps across many turns, is where a lot of 2026’s real engineering effort has gone. This isn’t just about answering a single prompt well. It’s about function calling that doesn’t hallucinate arguments, long context that stays coherent over hundreds of steps, structured output the surrounding code can parse reliably, and graceful recovery when the first plan doesn’t work. Harnesses like Aider, Cline, Continue, and OpenCode now point at local or self-hosted open models running behind an OpenAI-compatible endpoint through Ollama, LM Studio, or vLLM, and the harness itself turns out to matter almost as much as the underlying weights, the same model can perform very differently under a well-built agent loop versus a bare prompt.
Enterprise RAG and document processing is another heavy area, especially where data residency rules apply. A retrieval-augmented pipeline that runs roughly $2,275 a month on a frontier closed API can run for about $168 a month on an optimized open-weight model, according to one 2026 cost analysis, a 93 percent reduction with a fairly small performance hit. That math changes the conversation entirely for teams processing millions of tokens a month, where the difference isn’t marginal, it’s the line item that decides whether a product is profitable.
On-premise and regulated deployment is where open weights solve a problem closed APIs structurally can’t. Finance, healthcare, and government teams increasingly favor self-hosted open models specifically because the data never leaves their infrastructure. Security teams reviewing DeepSeek, for instance, will often approve the self-hosted weights running on internal hardware while explicitly prohibiting the hosted API. Same model family, very different risk profile: one keeps every token on servers the company controls, and the other sends data to a third party operating under a different country’s law.
Multilingual and domain-specific applications benefit heavily from the sheer number of fine-tunes the open ecosystem produces. Qwen’s multilingual strength has made it a common base for regional deployments. India-focused models like Sarvam 105B build directly on the open ecosystem to handle Indian-language reasoning specifically, something the big three closed labs haven’t prioritized as heavily. Healthcare startups have used smaller open models like Vicuna to power multilingual symptom-checker chatbots. Research groups fine-tune Qwen or Llama on archives of scientific literature to build source-backed question-answering systems for social science research. Pharma and materials-science teams use open models fine-tuned specifically for summarizing dense literature, cutting down review time on papers that would otherwise take a researcher days to read manually.
Edge and on-device deployment is a smaller but fast-growing category. Google’s Gemma line and Microsoft’s Phi-4 were both built explicitly for lower-latency, resource-constrained environments. Gemma 4 26B runs comfortably on a single modern GPU or high-end laptop, and edge-focused releases like Qwen3.5’s 0.8B variant target phones directly, trading some capability for a model that fits in a few hundred megabytes of memory and doesn’t need a network connection to run.
Worth noting: none of these benchmark numbers should be taken as a final verdict on their own. SWE-bench Verified, the most-cited coding benchmark, is heavily weighted toward Python repositories, so a model that tops the leaderboard can still underperform on a Rust or TypeScript codebase that looks nothing like the benchmark’s training distribution. Practitioners who actually deploy these models tend to run a small evaluation against their own repo before committing to one, rather than trusting a single leaderboard number. The same caution applies to reasoning and math scores: MMLU alone doesn’t capture reasoning depth, and a model that leads on one dashboard can trail on another. The four leaderboards worth checking regularly are Artificial Analysis, LiveCodeBench, Hugging Face’s Open LLM Leaderboard v2, and the LMSYS Arena rankings, and none of them should be treated as a single source of truth.
That’s a genuinely wide spread of real use, not experimental use. Two years ago the conventional wisdom was that if you wanted serious agentic or coding capability you paid for Claude or GPT and accepted the bill. That calculus has visibly shifted. Open-weight models now sit inside real production pipelines at real companies, not just research notebooks.
So Why Do People Keep Paying?
Given all that, the harder question is why closed models still take in the large majority of spend. A few forces explain it, and none of them are really about raw capability anymore.
The most straightforward one is inertia and convenience. A closed API is a single curl command away. There's no GPU to provision, no VRAM math to run, no quantization trade-off to weigh, no serving framework (vLLM, SGLang, TensorRT-LLM) to tune. For a team without in-house MLOps expertise, that simplicity has real value, and it's the reason enterprises describe closed models as lower risk even when the benchmark numbers say otherwise. One analysis put a realistic minimal self-hosted production deployment at $125,000 to $190,000 a year once you count infrastructure staff, uptime engineering, and the ongoing work of migrating to whatever model beats the current one six months from now. Self-hosting is still usually cheaper at real volume (50 to 75 percent cheaper by some estimates), but it's not free, and it's not zero-effort, and "free to download" quietly becomes "expensive to operate" the moment you need five nines of uptime.
The second force is what one 2026 analysis called the monetizable spread: not the raw capability gap between the best open and closed models, which has compressed dramatically, but the narrower slice of tasks where someone will actually pay a premium for the extra intelligence. That gap has been shrinking faster than the capability gap itself, but it hasn’t hit zero. On the hardest end of the difficulty curve (complex multi-step agentic coding, long-horizon tool chaining, frontier mathematical reasoning), closed models still hold a real, measurable lead. Claude Opus and GPT-5-class models continue to top SWE-bench Verified and Terminal-Bench by a few points over the best open coders, and for teams whose product depends on that last few points of reliability, the premium is still worth paying. Anthropic’s Claude Code alone reportedly runs at a $2.5 billion annualized revenue rate, which says something about how much some customers value that reliability at the margin.
Geopolitics adds a layer most cost calculators don’t capture. The strongest open-weight labs right now (DeepSeek, Qwen, Kimi, GLM) are Chinese, and that raises a legal-review question for a lot of Western enterprises that has nothing to do with model quality: are you comfortable building a product on weights released by a company operating under Chinese law, even if you’re running those weights entirely on your own servers? For regulated industries this isn’t rhetorical. It’s a real compliance question that legal and security teams have to sign off on before any code gets written, and it pushes some organizations toward Western closed labs by default regardless of the benchmark comparison.
There’s also a simple trust-and-support argument. Closed vendors bundle in continuous safety patching, dedicated engineering support, service-level agreements, and a company that answers the phone when something breaks in production. Open source gives you a GitHub issue queue and a Discord server (often excellent, often fast) but not contractually obligated to fix your specific outage by Tuesday. For high-stakes workflows in healthcare or finance, that difference in accountability matters more than a few benchmark points.
Perhaps the most persistent factor, though, is simple habit. Enterprises adopted closed AI first because a couple of years ago it really was the only credible option, and switching an established pipeline off a model that already works is its own project (new evaluation, new prompt tuning, new risk sign-off) even when the economics clearly favor moving. That inertia, more than any remaining capability gap, is probably the biggest reason 80 percent of token volume still flows to closed models that cost, on average, roughly six times as much per token as the open alternatives.
What This Actually Means Going Forward
None of this points to open models replacing closed ones outright, and it doesn’t point the other way either. What’s emerging instead, across nearly every serious deployment described in 2026 coverage, is a hybrid pattern: open models handle the high-volume, cost-sensitive, or data-sensitive middle of the workload, while a closed frontier model gets called in for the narrow slice of tasks that genuinely need the extra edge: the hardest 5 percent of coding problems, the highest-stakes reasoning, the tasks where a mistake is expensive enough that the token premium is trivial by comparison.
That’s a very different picture from “open versus closed” as a single either-or decision. It’s closer to how most companies already think about cloud infrastructure: you don’t run everything on the most expensive tier just because it exists, and you don’t run everything on the cheapest tier either. You match the tool to the task, and increasingly in 2026, the tool for most of the task is free to download.