Open Model Licenses Explained: Apache, MIT, and Llama Community License

// In plain English

When a lab releases an open-weights model you can download, it always comes with a license: a legal document that tells you what you are allowed to do with the file. Can you use it in a paid product? Can you redistribute it? Can you fine-tune it and sell the result? The license decides all of that — not the model card's marketing, and not the fact that the download was free.

Think of borrowing a power tool. One neighbor says "keep it, do whatever you want, no need to even tell me" — that's a permissive license like Apache 2.0 or MIT. Another neighbor says "sure, use it, but put my name on anything you build, don't use it to compete with my hardware store, and if you ever run a chain of 700 stores you have to come ask me first" — that's a community license like Meta's Llama license or Google's Gemma terms. The tool is the same kind of useful in both cases. The strings attached are completely different.

The key mental shift: "open" is not one thing. Some open models are as free to use as classic open-source software. Others are open to look at and run but carry real commercial restrictions. The word on the download button doesn't tell you which — the license does.

// Why it matters

If you are just experimenting on your laptop, the license barely matters — almost every open model lets you tinker for free. The license becomes load-bearing the moment you do something commercial: ship a product, serve the model to customers, or build a company on top of it. Pick the wrong model and you can be forced to rip it out late, or expose yourself to a contract you never read.

• Can I use it in a paid product at all? Permissive licenses say yes, unconditionally. Some community licenses say yes with conditions — and a few research-only licenses say no.
• Can I redistribute the weights or a fine-tuned version? Most allow it, but several require you to pass the same license along and to credit the original.
• Are there usage caps? Meta's Llama license has a famous clause: if your product reaches 700 million monthly active users, you must request a separate license from Meta. Tiny for a startup, real for a giant.
• Are there forbidden uses? Community licenses attach an acceptable-use policy (no weapons, no large-scale surveillance, no illegal activity, etc.) that legally binds you even though the weights are free.

There is also a subtler trap. A model can be advertised as "open" and still not be open source in the strict sense — meaning the Open Source Initiative (OSI), the body that defines the term, would not approve the license because it restricts who may use it or for what. That's the "open but not OSI-approved" gotcha, and Llama and Gemma both fall on that side of the line. For the conceptual background, see open weights vs open source and open vs closed models.

// How model licenses work

Open-model licenses fall into two broad families. Permissive licenses are short, standard legal documents reused across thousands of software projects — they grant nearly everything and ask for almost nothing. Custom community licenses are written by the lab that made the model, specifically for that model family, and they add conditions the lab cares about: branding, scale caps, and forbidden uses.

What a permissive license actually asks for

Apache 2.0 and MIT are the two you'll meet most. Both let anyone use the model commercially, modify it, redistribute it, and build closed-source products on top — for free, forever, with no scale cap and no acceptable-use policy. In exchange they ask for one small thing: keep the copyright notice and license text with any copy you redistribute. Apache 2.0 adds an explicit patent grant (contributors won't sue you over patents in the work) and a notice requirement for files you changed; MIT is even shorter and skips the patent language. Mistral's open models, many Qwen releases, and a large share of fine-tunes on Hugging Face ship under Apache 2.0.

What a community license adds on top

A community license starts from "you may use these weights" and then layers on conditions. Reading one means hunting for four things: a scale or usage cap, an acceptable-use policy, attribution/naming rules, and redistribution terms. The flow below is the checklist to run on any model before you build on it.

The model card is where you'll usually first see the license name; learning to read one is covered in how to read a model card. But the card only names the license — the binding terms live in the actual LICENSE file in the repository, and that's the text that governs you.

// License by license: Apache, MIT, Llama, Gemma

Here are the four licenses you are most likely to hit when picking an open model today, side by side. "OSI-approved" means the license meets the formal open-source definition — only the permissive two do.

The Llama Community License

Meta's Llama models are free to use commercially for the overwhelming majority of builders, but with three real conditions. (1) The 700M-user clause: if the product or company using Llama has more than 700 million monthly active users at the time of the model's release, you must request a license from Meta rather than relying on the default one. (2) Naming and attribution: if you redistribute Llama or release a model you built with it, the name must begin with "Llama" and you must display "Built with Llama," plus include the attribution notice. (3) The acceptable-use policy forbids a list of harms. Derivative models you train on Llama outputs inherit these terms.

Google's Gemma Terms

Gemma allows commercial use and fine-tuning with no user-count cap, which makes it simpler than Llama on scale. Its constraints are different: Google reserves the right to remotely restrict uses that violate its Prohibited Use Policy, and anyone you distribute Gemma (or a derivative) to must also receive and agree to those same use restrictions — the policy travels with the weights. So the practical Gemma question isn't "how big am I," it's "can I guarantee everyone downstream of me agrees to the use restrictions."

// Choosing a model and common pitfalls

A simple rule of thumb: if you want the fewest legal questions, pick a permissive (Apache 2.0 / MIT) model. You can build a closed product, charge for it, redistribute fine-tunes, and never worry about a scale cap. Choose a community-licensed model (Llama, Gemma) when its quality or fit is worth accepting a few conditions you can comply with — which, for most teams under hundreds of millions of users, is genuinely easy.

• Assuming "free download" means "do anything." Free to download is not free of terms. The license still binds you the moment you go commercial.
• Confusing 'open' with 'open source.' Llama and Gemma are open-weights but not OSI open source. If your procurement or compliance team requires an OSI-approved license, these won't qualify — check before you commit.
• Ignoring the acceptable-use policy. It is part of the license. Building a forbidden use (e.g., certain surveillance or harm categories) is a license violation even though nobody charged you.
• Forgetting the naming/attribution rule. Shipping a Llama-derived model without the "Llama" name prefix and "Built with Llama" notice breaks the terms — an easy, avoidable mistake.
• Trusting an uploaded copy's tag. A re-upload on Hugging Face can be mislabeled. Trust the original lab's LICENSE file, not a random mirror's tag. See run your first Hugging Face model and open model families.

// Going deeper

Once the four-license picture is clear, a few finer points separate a casual user from someone who can safely ship on open weights.

Derivative and synthetic-data terms. A subtle clause in several community licenses governs what happens when you train a new model on the licensed model's outputs. Llama's terms, for example, extend to models trained on Llama outputs — the obligations can follow the data, not just the weights. If your pipeline distills a community-licensed model into your own, read that clause carefully before assuming your output model is unrestricted.

Research-only and 'source-available' licenses. Beyond the four above, you'll meet licenses that allow research and personal use but forbid commercial use entirely, and 'source-available' or 'responsible-AI' licenses (such as the RAIL family) that permit commercial use but bake in enforceable behavioral restrictions. These are 'open' in the sense that you can see and run the weights, but they are not permissive — never assume a non-Apache/MIT license lets you build a product without reading it.

Two licenses in one download. Open releases often bundle two things with different terms: the weights (governed by the model license) and the surrounding code (often a separate, more permissive software license). Don't assume the code's MIT license covers the weights, or vice versa. Check each.

Where to go next. If you're picking a model to actually run, pair this with top open-source LLMs and the practical guides on running them locally — what is a local LLM and what is Ollama. The durable lesson is simple: the license is part of the model. Read it with the same care you read the benchmark scores, before you build, because it is far cheaper to choose the right license up front than to swap models after launch.