Skip to content
Velloreth
Technology News 11 min read

The Open Source AI Debate: Licensing and Freedom

Open-weight versus open-source, the OSI's AI definition, why major models fail it, and what developers should actually check before building on an 'open' model.

By

“Open source AI” is currently the most contested phrase in the industry’s vocabulary, and the contest is not academic. It determines what developers can build on, what regulators treat more leniently, and what marketing departments are allowed to imply about models that are, by the historical standard of open source, not open at all.

The short version of the state of play: the Open Source Initiative published a formal Open Source AI Definition (OSAID) in late 2024 that most frontier-scale “open” models fail to meet. Meta, whose Llama family is the most prominent example, publicly disagrees with the definition. Regulators, particularly in the EU, are writing the term “open source” into law with real compliance consequences attached. And underneath the definitional fight, a simpler practical question persists for working developers: what rights does this model’s license actually give me?

This piece separates the definitional fight from the practical one, and tries to be honest about where each matters.

What the Open Source AI Definition actually requires

The Open Source Initiative has guarded the Open Source Definition for software since the late 1990s. Its AI effort, developed through a multi-year global process with working groups across stakeholder classes, produced version 1.0 of the OSAID in October 2024.

The definition starts from the four freedoms familiar from free and open-source software, restated for AI systems:

  1. Use the system for any purpose, without having to ask permission.
  2. Study how the system works and inspect its components.
  3. Modify the system for any purpose, including changing its output.
  4. Share the system with or without modifications, for any purpose.

The innovative — and contested — part is what the OSI calls the preferred form for making modifications. For software, this is straightforward: the source code. For machine-learning systems, the OSAID says it requires three things together:

  • Data information: sufficiently detailed information about the training data — provenance, scope, characteristics, collection and selection methods, labeling, filtering — such that a skilled person could build a substantially equivalent system. The definition does not require redistributing data that cannot legally be shared, but it does require disclosing what it was, where it came from, and where obtainable.
  • Code: the complete source used to train and run the system, under OSI-approved licenses — data processing, training scripts, validation, tokenizers, inference code, architecture.
  • Parameters: the model weights or configuration, under terms that ensure their freedom.

A system meeting all of this, under the four freedoms, is Open Source AI. Anything less is something else — the OSI’s preferred term for the common middle ground being open weight: the parameters are public, but the system around them is not.

Why most major “open” models fail the definition

Apply the OSAID checklist to the most prominent openly-available models and the pattern is consistent:

Model familyWeights publicInference codeTraining codeDetailed training data informationOSAID-conformant?
Meta LlamaYesYesPartialNoNo
Google GemmaYesYesPartialNoNo
Mistral (flagships)Yes (some)VariesNoNoNo
Most Hugging Face “open” modelsOftenOftenRarelyRarelyRarely

The gap is almost never the weights — the industry has converged on releasing those for anything wanting community adoption. The gap is data information and full training code. This is not an accident: training data is simultaneously the most valuable competitive asset a lab possesses and a legal minefield, given ongoing litigation about copyrighted material in training corpora. Publishing a full data manifest is, for many labs, both strategically painful and legally risky.

Meta’s position has been explicit since before the OSAID’s release. In its response to the 2024 definition, the company argued that there is no single settled meaning of “open source” for AI, that software definitions do not map cleanly onto systems where training data is consumed rather than shipped, and that sharing weights and code is the practically meaningful contribution. Mark Zuckerberg’s 2024 public letter made the pragmatic case: open-weight models deliver most of the ecosystem benefit — broad use, fine-tuning, deployment flexibility — without requiring data disclosure that may be impossible or inadvisable.

The OSI and its supporters counter that “open source” is a term with a specific, battle-tested meaning, and that letting any weights release claim the label dilutes it into a marketing word. Yann LeCun and other Meta researchers have pushed back on the data-disclosure requirement as impractical for large models — an argument the OSI partially concedes by allowing “unshareable” data to be described rather than shipped, while still requiring the description.

Both sides have a point, which is why the debate does not resolve. The OSI is right that term inflation has costs: “open source” earns trust it has not always deserved when applied to restricted systems. Meta is right that a definition requiring what almost nobody currently provides risks making the term aspirational rather than descriptive. The compromise position — distinguishing “open weight” from “open source” — is gaining traction precisely because it lets both claims be honest.

The Llama license specifically

Llama’s license is the most scrutinized artifact in this debate, and it is worth being concrete about what it does and does not do.

What it provides: broad rights to use, reproduce, distribute, and fine-tune the models, including commercially, for most users. For the vast majority of developers and companies, the license is functionally permissive.

What it restricts: use by organizations above a large monthly-active-user threshold (the 700 million MAU clause in the relevant versions) requires a separate license; outputs cannot be used to train competing models; the “Llama” name and marks have their own rules. The custom license is not an OSI-approved license.

The 700 million clause is the one that draws the most fire, and the criticism is not subtle: the threshold happens to exclude a handful of Meta’s largest potential competitors, and no comparable restriction exists in any OSI-approved license. Under the Open Source Definition’s non-discrimination principle, a restriction targeting a specific class of users is disqualifying by the letter of the standard, regardless of whether it affects you.

For a working developer, the distinction that matters is rarely “does OSI approve?” It is the practical rights checklist:

  • Can I run inference locally, including commercially? (Usually yes.)
  • Can I fine-tune without asking permission? (Usually yes.)
  • Can I deploy the fine-tuned model in my product? (Usually yes, with mark and output-training caveats.)
  • Can I trust the license will not change under me? (The license version ships with the model version; the risk is more about future models than retroactive changes.)
  • What happens at the scale threshold? (Relevant only if you are, or might become, a very large platform.)

By that checklist, Llama is useful and often fine. By the OSI’s checklist, it is not open source. Both statements are true simultaneously, which is the source of most of the argument.

Why regulators are now in the definitional fight

The debate would be largely philosophical if “open source” were only a marketing term. It is not: regulators are writing the phrase into law with compliance consequences.

The most consequential example is the EU AI Act, which treats open-source AI components differently from proprietary ones in specific provisions — certain transparency and documentation obligations are adjusted or exempted for genuinely open-source releases meeting the law’s conditions. Which definition of “open source” gets adopted in implementing guidance determines which models qualify for the lighter treatment. France has pushed for a broader reading that would benefit its national champion, Mistral; other member states have favored a stricter reading closer to the OSI’s approach. The European Commission’s implementation choices here have direct competitive consequences for labs — and direct compliance-cost consequences for anyone building on their models.

The same definitional question is surfacing in other jurisdictions’ AI governance frameworks and in procurement rules: government and enterprise buyers increasingly want to know whether a model is “open” in a legally meaningful sense before adopting it, and the answer changes liability, audit, and supply-chain questions.

For developers, the regulatory angle matters in one specific way: if you build a product on a model you believe is “open source,” and that model’s classification later affects your compliance obligations in a market you serve, the license text and the model’s actual transparency artifacts — not its marketing page — are what will be examined.

The practical middle: what developers actually need

The definitional fight is worth understanding, but most engineers’ needs are narrower and more concrete than “is this OSI-approved open source AI?”

What you needWhat satisfies itNotes
Local / self-hosted inferenceOpen weights + inference codeAlmost all “open” models qualify
Commercial use of the modelCommercial-use grant in the licenseCommon; check size/threshold clauses
Fine-tuning for your domainFine-tuning rights in the licenseCommon; check output-training restrictions
Deploying fine-tunes in your productCommercial deployment rightsCheck marks and attribution requirements
Studying / auditing model behaviorWeights + architecture + some docsWeights allow inspection; full reproducibility needs more
Reproducing or independently modifying the systemOSAID-level data information + code + weightsRare at frontier scale; more common in research releases
Regulatory open-source treatmentDepends on the regime’s definitionCheck the specific law’s language, not the model’s blog post

The honest summary of what is available in 2026: open-weight models reliably deliver the first five rows; the sixth — genuine reproducibility and independent modification of the full system — remains rare at the scale where the models are most useful. Truly OSAID-conformant systems exist, particularly in research and smaller-scale releases, and some are genuinely impressive; they are just not where the capability frontier is.

That is a fine trade for most use cases. If you want to run a strong model locally, fine-tune it for your domain, and ship a product on top, open-weight models do that today. The gap matters most for researchers who need to reproduce training, for organizations with strict provenance requirements, and for anyone whose legal or policy position depends on the formal open-source claim.

What to check before you build

A short, practical checklist for evaluating an “open” model:

  1. Read the license, not the landing page. The actual LICENSE file in the repository governs. Landing-page language like “open” and “free” is marketing; the license text is the contract.
  2. Check commercial use explicitly. Most allow it; the restrictions are usually about scale, outputs, and marks.
  3. Check the training-data disclosure. If you have provenance requirements — from customers, regulators, or your own policy — “we don’t publish data details” is an answer you need before adoption, not after.
  4. Check the output-training clause. Some licenses prohibit using model outputs to train other models; relevant if your pipeline includes distillation or synthetic-data generation.
  5. Check the scale threshold. Large-platform clauses affect only a few companies, but “few companies” includes the companies that acquire or grow into them.
  6. Check who maintains it. An open-weight release with a single corporate steward and no community governance carries more concentration risk than one with a foundation, multiple contributors, and a documented release process.
  7. Distinguish the claim you are relying on. If your need is practical rights (rows 1–5 above), open-weight is likely sufficient. If your need is the formal open-source claim — for regulatory treatment, procurement, or policy — verify against the definition your jurisdiction or customer actually uses, which may or may not be the OSI’s.

Where this is heading

Three trends seem likely to define the next few years:

Terminology will keep splitting. “Open weight” and “open source” are converging on distinct meanings in serious discourse, even as marketing continues to blur them. Teams and policies that use the precise terms will make better decisions than ones that argue past each other with the same word.

Regulatory definitions will crystallize. As AI Act implementing guidance and other jurisdictions’ rules mature, the compliance consequences of “open source” classifications will get specific enough to plan around. At that point the definitional fight stops being philosophy and becomes a procurement and product-planning input.

Some frontier lab will move toward the definition, or something adjacent. The commercial and reputational incentives — regulatory relief, community trust, differentiation from fully closed competitors — are real enough that a major lab may one day ship a release that meaningfully closes the data-information gap, even if full reproducibility remains out of reach. Whether that becomes a genuine open-source AI at scale or a negotiated “open enough” category is one of the more interesting open questions in the space.

For now, hold both truths: the practical freedoms of open-weight models are genuinely valuable and worth using; and the formal open-source claim, as the institution that defined the term for software has defined it, remains largely unmet at the frontier. Build on what the license actually grants you, describe it accurately, and keep an eye on the definitions — because increasingly, the definitions have teeth.