Open vs. Closed: Ecosystems, Licensing, and Leverage

"Open" is one of the most load-bearing words in AI right now, and one of the least precise. Someone says their model is "open" and you still don't know whether you can download the weights, whether you can ship them in a product, whether the training data is anywhere you can see it, or whether the license would survive a ten-minute read by a real lawyer. Most of the time the answer is "some but not all of the above," and which ones matter depends entirely on what you're trying to do.

I find it helps to stop thinking of open and closed as two camps and start thinking of openness as a spectrum with several independent axes. A model can be weight-available but not commercially usable. It can have a permissive license but undisclosed training data. It can be fully reproducible in theory and practically impossible to retrain in practice. Once you separate the axes, the strategic moves the big players are making start to make more sense as positioning rather than ideology.

This post is about that positioning. What "open" actually means in 2026, why Meta, Mistral, and DeepSeek each picked the open side of the board for different reasons, why OpenAI and Anthropic and Google stay closed for different reasons, and who ends up with leverage when the dust settles.

What "open" actually means

There isn't one axis. There are at least six things you might mean when you say a model is open, and a given release might check any subset of them:

1. Weights. Can you download the parameters?
2. Architecture and inference code. Is there a reference implementation you can read and run?
3. Training data. Is the corpus disclosed, or at least described precisely enough to reconstruct?
4. Training recipe. Is the optimizer schedule, data mix, hyperparameter sweep, and post-training pipeline documented end-to-end?
5. License. Is it OSI-approved open source, or a bespoke "source-available" license with use restrictions?
6. Commercial use. Can a real company ship it in a real product without paying anyone or asking permission?

The Open Source Initiative finalized its "Open Source AI Definition" (OSAID) in late 2024, and under that definition an open AI system needs enough of these checked that you could reasonably study, modify, and redistribute it. The OSAID is somewhat controversial because it stops short of requiring the full training dataset, only "data information" sufficient to recreate an equivalent system. Stricter advocates (including the Free Software Foundation) think that's too lenient. Meta thinks it's too strict, which is why Llama is not OSI-approved open source even though Meta's marketing often calls it "open."

Look at where the checkmarks cluster. Weights and code are easy to release. Training data and the full recipe almost never are. The gap between those two groups is the gap between "open weights" and "open source."

The thing the matrix makes obvious: almost nothing clears all six boxes. The models people call "open" (Llama, Mistral Small, DeepSeek) are almost always weight-available with a reasonable license, but with training data undisclosed and the recipe only partially documented. The truly open releases (OLMo from AI2, BLOOM, K2 from LLM360) are rare and usually come from nonprofit or academic labs. In industry, "open" in 2026 almost always means weights-available under a custom license that doesn't meet the OSI definition.

Licenses: what the words actually do

If you work with open models professionally, the license is the most consequential detail on the model card, and it's easy to skip past. There are really only a handful of license families that matter in practice:

Click a row to expand. The key thing to notice: "commercial use" and "OSI-approved" are different columns, and most popular models only check one of them.

The two OSI-approved families (Apache 2.0 and MIT) are the safe harbors. If a model's weights are released under one of those, you can basically do whatever you want. Use it commercially, fork it, fine-tune it, ship it in a product, relicense your derivatives. Mistral's smaller models, Qwen, and DeepSeek all use one of these, and that's a huge part of why those models show up so often in production stacks.

The Llama Community License is where things get interesting, because it's the license that the biggest open-weight model family in the world actually ships under, and it is not open source. It's source-available. You can use Llama commercially if your product has under 700 million monthly active users, if you display "Built with Llama" prominently, and if you pass the license terms through to anyone who redistributes. For almost everyone reading this, those conditions are fine. But the OSI has explicitly declined to call the Llama license open source, and the distinction matters if your definition of "open" includes a guarantee that the terms can't change on you later.

Then there's the RAIL / OpenRAIL family, which tries to add use-based restrictions (no mass surveillance, no weapons, no discriminatory deployment). Those restrictions look reasonable in isolation. But the OSI's definition of open source has a "no discrimination against fields of endeavor" clause that explicitly prohibits them, which is why OpenRAIL fails the open-source test no matter how well-intentioned the restrictions are.

The thing to carry out of this: "open weights" and "open source" are not synonyms. Most of the models in your Hugging Face cache are the former. Very few are both.

Meta's move: commoditize the complement

The Llama strategy is the most-written-about open-weights play, and Meta is not releasing Llama out of altruism or ideology. They're doing it because it's a fairly textbook application of a very old piece of business strategy: Joel Spolsky's "Commoditize Your Complements."

The idea is that if your business sells product X, you want the things that are bought alongside X (its complements) to be as cheap and plentiful as possible. IBM sold PCs, so they wanted operating systems commoditized (the OS/2 era was a miscalculation). Google sells ads, so they want broadband, browsers, and Android commoditized. Meta sells attention (ads in feeds). They want LLMs commoditized, because if AI becomes a cheap, interchangeable ingredient, it strengthens the platform that sells attention and weakens the one thing that could have been an existential threat: a single frontier-AI provider owning the distribution pipe above Meta's content.

Watch the cycle: Meta releases weights, adoption spreads, downstream costs fall, and the value flows back to Meta as talent and standard-setting leverage. For Meta, the weights are closer to a subsidy than a product.

Here's the arithmetic. Suppose closed-API inference costs $15 per million output tokens, and open-weight inference costs$1. A million-token-per-day integration is $5,475/year closed, or$365/year open. Multiply by a hundred million integrations across the industry and the delta is enormous. If you're OpenAI that delta is your revenue. If you're Meta that delta is somebody else's revenue you just transferred to "whoever runs the inference," which increasingly is a hyperscaler that Meta doesn't care about.

The release itself is the move. Meta doesn't need to win the inference race; they just need to make sure nobody else can sit between their users and their content and charge rent. Open-weight Llama does that.

Mistral: sovereignty as a product

Mistral's motivation is different. France and the EU have been loudly uncomfortable with the idea that the foundation models their economies run on are all shipped from California, and Mistral has positioned itself as the credible European answer. The open side of that pitch is real: Mistral 7B and Nemo and Small are Apache-licensed, genuinely good, and deployable anywhere.

But Mistral also runs a closed API with their frontier models (Mistral Large, the Codestral line, and more recent agent-specific tuned models). The business is shaped like a barbell: open models that function as the flag-planting, ecosystem-building, "look, Europe can do this" product, plus closed models that function as the revenue engine. This is a common and coherent strategy. The open releases create developer pull. The closed releases capture value from customers who need the frontier and are willing to pay for it.

If you want a one-line summary of Mistral's bet: the EU will prefer a European model for reasons that have nothing to do with capability, and that preference is a moat. Whether the moat holds depends on whether European sovereignty concerns translate into actual procurement policy (the EU AI Act, the Gaia-X cloud initiative, public-sector mandates), and so far the signal is mixed but trending toward "yes, somewhat."

DeepSeek: the price floor

DeepSeek's arc is the most disruptive one of 2024-2025, and it's still reshaping pricing across the industry. Their playbook is simpler than Meta's and more aggressive. Release frontier-quality weights under MIT, publish unusually detailed technical reports, and serve the models on their own API at prices an order of magnitude below what US providers charge.

DeepSeek-V3 landed in December 2024 with roughly GPT-4-class quality at something like 1/10th the API price. DeepSeek-R1 followed in January 2025, matching o1-class reasoning, also open-weight, also cheap. The effect was immediate: within a quarter, every major closed provider had cut flagship prices, and the "reasoning" tier got repriced as a commodity.

The open-weight line acts as a floor that drags the closed-API line down over time. Watch the ratio on the right: the gap compresses every quarter, but never fully closes.

An open-weight model served by any competent inference provider sets a price floor for the rest of the market. If a closed API charges $20 per million output tokens for roughly the same quality you can get from DeepSeek-R1 for$2, most sophisticated buyers will either switch outright or use the open model as leverage in their procurement. The closed provider has three choices: match the price (painful), demonstrate enough quality advantage to justify the premium (hard, especially as open models close the gap), or differentiate on something other than the model itself: safety guarantees, enterprise features, integration depth, latency SLAs.

All three are happening in parallel. The floor keeps moving down every quarter, and the closed APIs move down with it.

The math of "just host it yourself"

One small piece of arithmetic that helps here. "Open model is 10× cheaper" doesn't translate directly into a 10× savings for any organization that self-hosts. The savings only show up at certain volumes.

Imagine you run a product that sends a million output tokens per day through an LLM. On a closed API at $10/Mtok, you pay $10/day, or about $3,650/year. If you self-host on a single rented H100 at $2.50/hour, the GPU alone costs $21,900/year whether you use it or not. At a million tokens/day you're using maybe 5% of that GPU's throughput — you're paying ~$6 per effective Mtok served, six times the API price, because the GPU sits idle most of the time.

Now imagine the same product grows to 100 million output tokens/day. The API bill is $365,000/year. One H100 maxes out around 14M output tokens/day for a 70B-class model, so you'd need ~7 of them, for ~$153,000/year, less than half the API cost. The crossover is somewhere around 15-20M tokens/day for this size of model, and moves around with GPU prices and batching efficiency. Below the crossover, open models save you nothing on inference cost; above it, they can save a lot. Who benefits from open weights in practice? Big products, big clouds, and anyone running enough volume to keep hardware hot.

Why the closed providers stay closed

Meta can afford to give Llama away because the weights are not Meta's product. For OpenAI, Anthropic, and Google's frontier Gemini line, the weights are the product, or at least the nearest proxy to one, and opening them has costs none of the three are willing to pay.

The stated reason is safety. Once you release weights you can't un-release them. If a model turns out to be dangerously capable in some way you didn't anticipate (bio-risk uplift, cyberoffense, persuasion), the mitigations you had running behind your API (refusals, classifiers, rate limits, KYC on sensitive use cases) all disappear. Anthropic in particular has been explicit that their Responsible Scaling Policy assumes deployment through a controlled surface. You can argue with whether that actually makes the world safer, but the argument for staying closed on safety grounds is coherent.

The unstated reasons are also real. Closed weights let you run A/B tests on pricing without a reference point. They let you prevent fine-tunes that would compete with your own offerings. They make it harder for a rival lab to distill your model into theirs (though the recent distillation work suggests "harder" may not mean "impossible" for long). And they protect you from the liability question of "what happens when someone fine-tunes your model to do something awful and then sues you."

Put differently: staying closed is a choice, and the choice has real costs on both sides. The open labs are betting the ecosystem win is worth the lost direct monetization. The closed labs are betting the monetization and safety story is worth the lost ecosystem.

A small amount of math: the "commoditize" inequality

Here's the decision that underlies Meta's release strategy, written as cleanly as I can. Say a company earns revenue $R$ from its core product, and the total cost of access to that product is $C_\text{core} + C_\text{comp}$, where $C_\text{comp}$ is the cost of the complements users buy alongside it. Users buy as many units as the total price allows, so demand for the core is something like $D(C_\text{core} + C_\text{comp})$, a decreasing function.

If Meta spends $X$ dollars releasing an open model that cuts $C_\text{comp}$ (the cost of LLM inference in your feed-generation pipeline, say) by $\Delta$, then the revenue change is approximately:

where $\varepsilon$ is the demand elasticity for the core product. For Meta, $R$ is on the order of $150B/year and the relevant elasticity is non-trivial. Even a small fractional cut in AI-serving costs across the industry, compounded across their product surface, justifies a training run that costs tens or hundreds of millions.

You don't need to sell the thing you open-source. You need the people who buy your real product to have cheaper complements.

How to actually check if a model is open

Most of this post has been at the strategy level. Let's come down to something tactical: when you're looking at a model on Hugging Face and deciding whether you can ship it, what do you actually check? Here's the short version as code:

from huggingface_hub import HfApi, hf_hub_download
import json, re
 
api = HfApi()
 
OSI_APPROVED = {
    "apache-2.0", "mit", "bsd-3-clause", "bsd-2-clause",
    "isc", "mpl-2.0",
}
 
def profile(repo_id: str) -> dict:
    info = api.model_info(repo_id)
    license_id = (info.card_data or {}).get("license", "unknown")
    tags = set(info.tags or [])
 
    # Try to pull the README text for data disclosures
    readme = ""
    try:
        path = hf_hub_download(repo_id, "README.md")
        with open(path) as f:
            readme = f.read().lower()
    except Exception:
        pass
 
    mentions_data = bool(re.search(r"training\s+data|pretraining\s+corpus|dolma|redpajama", readme))
    mentions_recipe = "training" in readme and "hyperparameter" in readme
 
    return {
        "repo": repo_id,
        "license": license_id,
        "osi_approved": license_id in OSI_APPROVED,
        "commercial_ok": license_id in OSI_APPROVED or "llama" in license_id,
        "training_data_disclosed": mentions_data,
        "recipe_disclosed": mentions_recipe,
        "gated": info.gated is not False,
    }
 
for repo in [
    "meta-llama/Llama-3.1-8B",
    "mistralai/Mistral-7B-v0.3",
    "deepseek-ai/DeepSeek-R1",
    "allenai/OLMo-2-1124-7B",
]:
    print(json.dumps(profile(repo), indent=2))

This isn't a substitute for reading the actual license, and it won't catch the subtleties (Llama's MAU threshold, Gemma's Prohibited Use Policy, RAIL restrictions). But it's a fast sanity check before you invest engineering time assuming a model is safe to ship.

Misconceptions

"Open weights means open source." No. Open source is a specific legal concept, codified by the OSI since 1998, and the OSAID extended it to AI in 2024. Open weights means the parameters are downloadable. The two can coincide (OLMo, Mistral's Apache-licensed models) but usually don't. Llama is the most common case of weights-available-but-not-open-source, and describing it as "open source" in a pitch deck or a procurement doc is a category error that causes real problems once legal gets involved.

"Closed models are always more capable." This was broadly true through most of 2023 and became steadily less true through 2024. By late 2025 the gap between frontier closed and frontier open was small enough on most benchmarks that it didn't dominate procurement decisions. On reasoning, DeepSeek-R1 is competitive with o1 and o3. On general capability, Llama 3.1 405B is within a few points of GPT-4-class models. The gap is real and exists, especially at the absolute frontier, but "open is always worse" stopped being accurate somewhere in 2024 and hasn't come back.

"Open-source models can't be regulated." The opposite: they can be regulated, they just have to be regulated differently. The EU AI Act carves out reduced obligations for "free and open-source" general-purpose AI models, but only if they aren't deployed as high-risk systems and only if they're genuinely open (which knocks Llama out). What open-source does make harder is localized control: you can't revoke a download. But rules about how and when the model gets used, who can deploy it in regulated contexts, and who's liable when something goes wrong, are all very much on the table.

"Eventually everyone will be open." I don't think so. The frontier models, where the marginal training dollar actually buys new capability, have strong reasons to stay closed: training cost recovery, safety surface management, and fine-tune-proofing. What's more plausible is a stable stratification where last-generation quality becomes open and commoditized, and the frontier stays closed and monetized. That's roughly the shape the industry has settled into, and the gap between "commoditized tier" and "frontier tier" seems to be shrinking on capability but not disappearing on accessibility.

What's next

The open-vs-closed debate is partly about economics (who captures value), partly about licensing (what you can legally do), and partly about control (who can revoke access, who bears liability). Underneath all three is a question I've deliberately avoided in this post: what happens when these models actually cause harm, and who's responsible?

The next post covers Safety and Alignment: The Landscape in 2026, how the field is thinking about model behavior, evaluation, and governance as capabilities scale, and how the open/closed divide reshapes the entire safety conversation.

Additional reading (and watching)

• Open Source Initiative. (2024). The Open Source AI Definition (v1.0). The formal specification of what it takes for an AI system to count as open source. Note the compromise on training data (data information, not the data itself).

• Groeneveld, D., et al. (2024). OLMo: Accelerating the Science of Language Models. Allen Institute for AI. The reference example of a fully open release: weights, code, training data (Dolma), and permissive license.

• Meta. (2024). Llama 3.1 Community License Agreement. The license document itself. Pay attention to sections 1.b.i (the 700M MAU clause) and 2 (attribution).

• Spolsky, J. (2002). Strategy Letter V. The canonical statement of "commoditize your complements" in tech strategy. Older than any modern LLM but the logic maps cleanly.

• Jiang, A. Q., et al. (2023). Mistral 7B. The original Mistral paper. More importantly, the Apache-2.0 release note that signaled their positioning.

• DeepSeek-AI. (2024). DeepSeek-V3 Technical Report. Unusually detailed on training recipe and MoE architecture choices; the open-weight + MIT + cheap-inference combination that set the pricing precedent.

• DeepSeek-AI. (2025). DeepSeek-R1: Incentivizing Reasoning Capability in LLMs via Reinforcement Learning. The reasoning model that caused the January 2025 pricing reset across the industry.

• Touvron, H., et al. (2023). LLaMA: Open and Efficient Foundation Language Models. The original LLaMA paper. Useful both for the model details and for Meta's framing of what "open" meant for them at the time (it has since shifted).

• European Union. (2024). Regulation (EU) 2024/1689 (AI Act), Articles 53-55. The general-purpose AI provisions and the open-source carve-outs, with the systemic-risk threshold at $10^{25}$ FLOPs.

• Dubey, A., et al. (2024). The Llama 3 Herd of Models. The 405B paper. The training-recipe appendix is the most detailed public account of a frontier-scale training run to date.

• Bommasani, R., et al. (2023, updated 2024). The Foundation Model Transparency Index. Stanford HAI. An attempt to score foundation model releases on 100+ transparency indicators; a useful empirical anchor for where each lab actually sits on the openness spectrum.