Open-Source LLMs in 2026: What's Actually Open, and How to Pick One
Most open-weight LLMs aren't open source. A builder's map to who ships open models in 2026, what they cost, where they run, and when to skip closed.
Open-source LLMs are catching up to Claude and GPT. Most of them are not how you think as “open source”. Picking one has less to do with the model than with the license it ships under and the host you run it on. This guide maps these LLMs landscape: who ships open models now, why they give them away, what they cost, where they run, and when to reach for one instead of a closed model.
You have read that open-source AI is catching up.
DeepSeek beat this. Qwen beat that. Llama is free and everywhere.
That story is real. It is also hiding two things that change what you should do about it.
The first: almost none of it is open source. The second: the free models are not a gift. They are a weapon aimed at whoever charges you for AI, and in 2026 the weapon changed hands.
I went looking for an open model to run a high-volume job cheaply. I expected to spend the afternoon comparing benchmarks.
Instead I spent it figuring out which “open” models I was actually allowed to build on. Why the one topping the leaderboard is Chinese. Why the same model charged me four different prices depending on where I clicked run.
The landscape is not confusing because the technology is hard. It is misleading because three different things wear the same word. A license, a strategy, and a hosting bill all call themselves “open,” and nobody separates them for you.
So here is the map, in the order it actually matters.
What’s inside:
The Open-Source LLM Field Guide: Five Buckets for Every Name: the map that sorts every lab, model, license, host, and metric, so no name is left homeless.
Open-Source vs Open-Weight: Why Most “Open” LLMs Aren’t Actually Open Source: what “open” really means, and the license clause that can bill you.
Who Ships Open Models Now, and Why the Leaderboard Went Chinese: the current map, and the surprise at the top of it.
Why Would Anyone Give Away a Frontier Model? Open Weights Are a Weapon: the strategy behind free models, and what makes them survivable.
How to Read an Open Model’s License Before You Ship: the pre-build check that keeps a “free” model from becoming a legal problem.
How to Pick Where Your Open Model Runs: Groq, Together, Bedrock: same model, different physics, and how to choose.
How to Decide Between an Open Model and Claude or GPT: when open saves real money, and when closed still wins.
The Open-Model Decision Card, and Why Your Moat Is Never the Model: the one-page call sheet, and where durable value lives.
By the end: you can pick an open model, its license, and its host for a real project, and know when not to bother.
Hi, I’m Jenny 👋
I believe anyone can thrive with AI, not by mastering the tools, but by building real things with them. I run Build to Launch and the Practical AI Builder program, where we go from experimenting to shipping.
If you’re new to Build to Launch, welcome! Here’s what you might enjoy:
The Open-Source LLM Field Guide: Five Buckets for Every Name
The map has five layers, and every name you are about to meet sits on one of them.
They stack in an order, so start at the top.
A lab trains the model: DeepSeek, Meta, Alibaba’s Qwen team, Mistral, Moonshot.
What they ship is a model, an actual file of trained weights, usually a family in a few sizes: DeepSeek V4, Llama 4, Qwen3, GLM-5.
Every model ships under a license, the fine print on what you are allowed to do with those weights. This is where “open” gets slippery enough to fill the next section.
Then comes the layer that decides your build. You never need to download a frontier model onto your laptop, so it runs on someone else’s GPUs behind an API, and that someone is a hosting lane. There are five of them, and picking one is discussed in depth below.
The last layer is the measuring sticks you judge lanes on. A token is a chunk of text, very roughly three-quarters of a word, and it is the unit everything is priced in. The rest are dollars per million tokens, tokens per second for raw speed, and time to first token for lag.
Five layers, one order: a lab trains a model, the model ships under a license, you run it through a host, and you judge the everything on a few numbers.
Open-Source vs Open-Weight: Why Most “Open” LLMs Aren’t Actually Open Source
Open source has a definition, and most “open” models fail it.
The Open Source Initiative sets the bar: release the weights, the training data information, and the code that built it. The license must let anyone use, study, modify, and redistribute it for any purpose.
Open weight clears a much lower bar. You get the finished weights, a license, and little else.
That gap is not academic. The OSI looked at Llama and ruled it out: “Meta is confusing ‘open source’ with ‘resources available to some users under some conditions.’”
Some conditions. Here is one.
Llama’s license has a ceiling at 700 million monthly active users. Cross it on the model’s release date, and you must request a license from Meta, granted “in its sole discretion.” A size exists at which your right to use the model switches off.
There is another place. Llama 4’s multimodal rights are not granted to companies based in the European Union, and every Llama 4 model is multimodal. A European company installing Llama 4 to train on images is outside the license before it writes a line of code.
The traps are not only Meta’s. MiniMax M3 sits near the top of the open leaderboard, yet its license grants use “for non-commercial purposes”. Commercial use above $20M a year needs “separate, prior written authorization.”
A model everyone calls open, and you cannot legally build a business on it without asking first.
For contrast, look at what fully open looks like. AllenAI’s OLMo 2 ships the weights, the training code, the checkpoints, the logs, and the actual dataset, under Apache 2.0.
You can rebuild it. Almost nobody else lets you.
That is the real cost of open weight. Without the data and the recipe, you cannot audit the model for what it was trained on, you cannot reproduce it, and you inherit whatever legal exposure is buried in data you never saw.
You are not owning open source. You are renting a black box under a EULA. Read the license before the benchmark.
Who Actually Ships Open Models Now, and Why the Leaderboard Went Chinese
The roster changed faster than my mental model.
Here is who ships a current open-weight flagship as of July 2026:
On Artificial Analysis’s open leaderboard, the top open models are GLM-5.2, MiniMax-M3, DeepSeek V4, and Kimi K2.6.
Surprisingly (or not), every one of them is Chinese. Meta, Google, and Mistral trail.
The companies that made “open” a marketing word are quietly walking away from it.
Meta shelved Llama 4 Behemoth, its biggest model, and in April 2026 shipped Muse Spark, its first closed, API-only frontier model. Alibaba kept its small Qwen tiers open and made its flagship, Qwen3.7-Max, proprietary.
Read those two moves together and a pattern falls out. Leading on open is now a challenger’s play, not an incumbent’s. The labs that already have distribution are hedging back toward closed, while the labs trying to take share give their best work away.
Which raises the obvious question.
Why Would Anyone Give Away a Frontier Model? Open Weights Are a Weapon
Nobody spends nine figures training a model and releases it out of generosity.
Mark Zuckerberg said the quiet part in his 2024 open-source letter. Meta open-sources so it is “not locking into a competitor’s closed ecosystem where they can restrict what we build.” He compared it to being “constrained by what Apple will let us build on their platforms.”
Strip the framing and the logic is simple. Push the price of one layer to zero so you can sell or protect the layer next to it.
Meta’s real business is apps and ads, not model API calls. A free frontier model does two jobs at once: it commoditizes the paid product that OpenAI and Anthropic sell, and it keeps Meta off anyone else’s platform toll.
Meta never needed to sell the model. It needed the rival’s version to stop being worth paying for.
Then the weapon changed hands.
Once Meta had ecosystem share, it started hedging back to closed. Meanwhile the Chinese labs picked the weapon up and aimed it at everyone. DeepSeek V4-Flash runs at $0.09 per million input tokens, and Chinese open weights now make up around 61% of the top-model token traffic on OpenRouter.
When your capability is a commodity, giving it away costs you little and costs the incumbent charging for it a lot.
That only works if serving the model is cheap. The design decision that makes it cheap is the mixture-of-experts architecture.
DeepSeek V3 has 671 billion parameters, but only 37 billion are active per token. A router picks a handful of expert sub-networks for each token, so the compute and the memory bandwidth you pay for scale with the active count, not the total. The model holds 671B worth of knowledge and serves at roughly 37B worth of cost.
That decoupling is the reason frontier-grade output costs pennies in 2026 and could not in 2023, when a dense model computed every parameter for every token.
One more number deserves a second look. You have seen the claim that DeepSeek trained V3 for $5.6 million.
That figure is the final training-run compute only, about 2.788 million GPU-hours at $2 each, and the paper says so plainly. It excludes the research, the failed runs, and the hardware.
SemiAnalysis put the real server bill closer to $1.6 billion, noting the headline number “does not include research and development, infrastructure, and other crucial costs.” Same lesson as the license. The number everyone repeats is not the number that is true.
That is the strategy and the economics. You can see the game now: open weight, not open source, and a price war nobody is calling a price war.
The rest of this guide is the part you can act on: which license won’t bite you, where to run the model, and whether to use an open one at all. It all comes together in the Decision Card at the end.
How to Read an Open Model’s License Before You Ship
The license, not the benchmark, is what can stop your product. Read it first, and read it for four things.
First, a user or revenue ceiling. Llama switches off above 700M monthly active users; Kimi K2’s Modified MIT adds attribution duties above 100M users or $20M a month. You will likely never hit these, but “likely never” is a business decision, not a default.
Second, a geographic carve-out. Llama 4 excludes EU companies from its multimodal rights. If your users or your servers are in the wrong place, the license is already broken.
Third, a commercial gate. MiniMax M3 is non-commercial unless you get written authorization. This is the one that surprises people, because the model is free to download and still not free to sell against.
Fourth, attribution and naming. Llama makes you display “Built with Llama” and prefix any model you train on its outputs with “Llama.” Minor, but it is a contract term, not a suggestion.
Sort every model into one of three tiers and the decision gets fast.
Apache 2.0 and MIT models ship freely: Mistral Large 3, Gemma 4, DeepSeek V4, GLM-5.2.
Open-weight-with-limits models need a ceiling check: Llama, and Qwen’s larger tiers.
Non-commercial models like MiniMax M3 you skip unless you plan to ask.
One trap: licenses change per version. Gemma 1 through 3 shipped under Google’s restrictive terms; Gemma 4 moved to Apache 2.0. Check the version you are shipping, not the family you remember.
How to Pick Where Your Open Model Runs: Groq, Together, Bedrock
The same open model is a different product depending on where you run it. Speed and price swing wildly with the host, and picking one is a real decision, not a detail.
Take gpt-oss-120b. In July 2026 on Artificial Analysis, identical weights run at 1,987 tokens per second (raw output speed) on Cerebras. They run at 480 on Groq.
DeepInfra serves it at about $0.05 per million tokens. Their summary: a 314% speed spread and a 2.6x price spread on one model.
Step back, because the word host hides the mechanics.
An open model is not something you download and wrestle onto your laptop. It sits on someone else’s GPUs, behind an API endpoint you call over the internet.
The question is whose GPUs, and that comes down to your workload:
Just starting: a serverless API. Together, Fireworks, or DeepInfra keep the model running and bill per token, from roughly $0.09 to $1.74 per million. You grab a key and you are calling it in minutes.
Latency is the product: speed silicon. Groq and Cerebras run open models on custom chips, several times faster for a small premium.
Regulated: a cloud bundle. AWS Bedrock, Vertex, or Azure run the same models on the invoice you already pay, next to your data and behind the IAM you already set up.
Past ~100 million tokens a month: self-host. Rent GPUs and serve with vLLM, or run a smaller model locally with Ollama; a fixed GPU bill finally beats per-token pricing.
Don’t want to choose: an aggregator. OpenRouter fronts seventy-plus of these providers behind one API key, so you switch hosts by changing a string.
Prices swing by host and model: the same DeepSeek V3 runs from $0.38 to $0.89 per million tokens across hosts. Artificial Analysis has the exact figure for every model on every host, so check it before you commit.
Whichever you pick, using it looks almost like using Claude or GPT. You get an API key and point your code’s base_url at the host’s endpoint. Most are OpenAI-compatible, so the call you already write barely changes.
Now, why the spread? Same outputs, different physics underneath, and it comes from hardware, not quality.
Groq’s LPU keeps the model in on-chip SRAM, runs deterministically with no runtime scheduling, and drops the high-bandwidth memory that GPUs rely on. That buys latency and gives up capacity, so the model has to be sharded across many chips. Cerebras makes the same trade at wafer scale.
The GPU hosts, Together and Fireworks and DeepInfra, batch many requests on H100s and B200s. That maximizes throughput per dollar and raises the time to first token.
So fast and cheap are not two quality tiers. They are two design philosophies, and you pick by your workload: real-time voice needs the fast lane, bulk overnight processing wants the cheap one.
The cloud bundle looks overpriced until you see what it sells. AWS Bedrock runs open models at a premium to Groq, but it is not selling the model. It is selling unified billing, IAM, no data egress, compliance, and keeping inference next to data you already store on AWS.
For a regulated team, that bundle is the product and the model is the loss leader.
Notice the move, because you have seen it before. The provider’s margin on the model itself is racing toward zero, that $0.38 floor barely above the cost of serving it. They give the model away at cost to sell the thing beside it: raw speed, custom silicon, or the cloud bundle.
It is the same play the model labs ran, one floor up.
How to Decide Between an Open Model and Claude or GPT
Start with the honest part. At the frontier, closed still wins.
The best open models trail the best closed ones by a 3 to 6 point Intelligence Index gap, down from about 13 a year ago but not gone. The gap widens on the hardest reasoning and agentic tasks, and closed models hallucinate less. If your product lives or dies on the single hardest 5% of requests, pay for the closed model and move on.
Everywhere else, open has real, specific wins. There are four worth knowing.
The first is cost at scale.
The crossover sits around 100 million tokens a month; below it, a managed API is usually cheaper once you count ops. One team that moved two high-volume pipelines to self-hosted Qwen cut costs from $1.50 to $0.15 per million tokens, 90%, and still warned that below roughly 100k requests a day the managed API wins.
The second is privacy.
If you cannot send data to OpenAI at all, a self-hosted open model is the GDPR-clean path, and there is no closed equivalent.
The third is latency.
For real-time work, Cerebras serves Qwen at about 525 tokens per second against roughly 92 for a standard closed API.
The fourth is control.
You own the weights, so no vendor deprecates your model out from under you, and migrating is a change of base URL.
What working builders do is route by task. Send bulk, private, and high-volume work to an open model, send the hardest reasoning to a closed one, and keep a closed fallback wired behind a feature flag.
The question was never open or closed. It is which job, at what volume.
The Open-Model Decision Card, and Why Your Moat Is Never the Model
Everything above collapses into one page. Save it for your references:
THE OPEN-MODEL DECISION CARD (as of July 2026)
1. LICENSE: check before the benchmark
- Apache 2.0 / MIT: ship freely (Mistral Large 3, Gemma 4, DeepSeek V4, GLM-5.2)
- Open-weight + limits: check the ceiling (Llama = 700M MAU + no EU multimodal;
Qwen large tiers = 100M MAU)
- Non-commercial: needs written OK (MiniMax M3). Skip unless you'll ask.
- Grep the license for: user/revenue ceiling, geographic carve-out,
commercial gate, attribution.
2. HOST: same model, different physics
- Need speed (real-time, voice): Cerebras / Groq (specialized silicon)
- Need cheap (bulk, batch): DeepInfra / Together / Fireworks (GPU batching)
- Need the bundle (already on AWS/Azure, compliance, data-gravity):
Bedrock / Vertex
- Compare the same model across hosts on artificialanalysis.ai first.
3. OPEN vs CLOSED: which job, what volume
- Under ~100M tokens/mo, no privacy need: closed API usually wins
- Over ~100M tokens/mo, or on-prem/regulated, or need sub-0.3s latency: open
- Hardest reasoning / agentic / multimodal: closed, still (3-6 pt gap)
- Default: route by task, keep a closed fallback behind a flag.
Now the part that outlasts the card. The same logic that made the model free is already eating the layer that runs it.
Gartner expects inference on a trillion-parameter model to cost over 90% less by 2030. In 2023, a16z argued that infrastructure was capturing the value in AI. By 2026 that flipped: the durable moats are proprietary data, deep workflow integration, and distribution, and “model selection is closer to a commodity choice than a competitive advantage.”
Which tells you where to spend your effort.
Your moat is never the model, and increasingly not the host either. It is your users, your context, and the workflow a competitor cannot clone by downloading weights.
So pick the cheapest model that clears your quality bar, run it on the host that fits the workload, wire a fallback, and stop treating the model like the asset. The model is the commodity. What you build around it is the company.
Next Steps
What you can do today:
Pull the license of the open model you are eyeing and check it for the four clauses: a user or revenue ceiling, a geographic carve-out, a commercial gate, and attribution.
Drop one model into artificialanalysis.ai and compare it across a fast host and a cheap host before you commit to either.
Write down the monthly token volume where you would move a task off Claude or GPT to an open model. That number is your switch point.
If this made the open-model landscape navigable, share it to someone who will also benefit from reading it.
And if someone shared this with you, subscribe free so you don’t miss the next guide.
Which open model are you reaching for first, and what are you running it on?
— Jenny
Why Upgrade · Practical AI Builder Program · Claude Hub · AI Agents
Great, no nonsense article