Open weights is not open source — what your model's licence actually allows

This trips up more people than it should, and I include the version of me that shipped a model catalogue without thinking hard enough about it. Two models can sit in the same folder on the same Mac, both downloaded free, both running offline — and carry meaningfully different rules about what you're allowed to do with them. If you're using a local model for client work or inside a product, that difference is worth ten minutes of your attention.

Three things people collapse into one word

"Open" is doing far too much work in this space. It's worth separating what actually varies:

• Open weights. The trained parameter files are publicly downloadable. You can run the model yourself. This is the thing that makes local AI possible at all, and it's genuinely significant — but on its own it says nothing about permissions.
• Open source. The licence meets the established definition: free use for any purpose, including commercial, with no restrictions on fields of endeavour. Apache 2.0 and MIT qualify. A licence that says "you may not use this for X" does not, however reasonable X is.
• Open training data. Almost nobody does this. The overwhelming majority of "open" models publish weights while keeping the training corpus private. If reproducibility matters to you, assume you don't have it.

A model can be the first without being the second, and virtually none are the third. When a vendor says "open model", they nearly always mean the first.

Two licence shapes you'll actually meet

Permissive open-source licences — Apache 2.0 and MIT are the common ones. Use it commercially, modify it, redistribute it, build a product on it. Apache 2.0 also carries an explicit patent grant, which is a genuine advantage for anyone shipping software. The obligations are light: keep the licence and attribution intact.

Custom vendor licences — written by the company that trained the model, and each one is its own document. These typically permit broad commercial use, which is why they feel open in practice, but they commonly add an acceptable-use policy listing prohibited applications, and they usually require that you pass the same terms downstream to anyone you give the model to. Some also reserve rights for the vendor that a permissive licence wouldn't.

None of that makes a custom licence unreasonable — restricting weapons development or mass surveillance is a defensible thing for a vendor to do. It does make it not open source, and it does mean you have to read it rather than assume.

What this looks like in a real lineup — ours

I'll use our own tiers as the worked example, partly because I can state them with certainty and partly because they make the point better than a hypothetical would. These are the licences of the underlying base models we ship:

Six of seven are Apache 2.0. One — Quick — is Google's own Gemma Terms of Use, which is a custom licence rather than an open-source one. Same app, same machine, same download flow, different rules. Nothing about the interface tells you that, which is precisely the problem this article exists to fix, and it's why we list the licence and base model for every tier rather than just saying "open".

What about the text and code it generates?

This is the question everyone actually has, and I want to be careful here because it's the one where confident internet answers do the most damage.

The general position is that a model's licence governs the weights and your use of them, and most vendors do not claim ownership of what you generate. That's the common reading, and it's why people use these models commercially without much anxiety. But two things genuinely complicate it. First, a custom licence with an acceptable-use policy restricts the purposes you may use the model for, and generating output is a use — so a prohibited application doesn't become permitted just because the restriction was about the model rather than the text. Second, whether AI-generated material attracts copyright at all, and who holds it, is unsettled and varies by jurisdiction.

So: for ordinary commercial work with an Apache 2.0 model, the position is about as comfortable as it gets. For anything where the answer really matters — you're shipping generated code into a product you'll license onward, or your industry is regulated — read the actual licence for the actual model, and talk to a lawyer. I build inference engines; I'm not qualified to tell you how this resolves for your situation, and anyone on the internet who tells you confidently that they are should be treated with suspicion.

How to check what you're running, in about two minutes

1. Find the base model's real name. Not the product name your app gives it. You want the upstream identifier, like Qwen3.6-27B or Gemma-4-26B.
2. Open its model card. On Hugging Face the licence is listed in the sidebar and the full text is usually in the repository files.
3. Read the licence itself, not the summary. If it says Apache 2.0 or MIT you're in permissive territory. If it's named after the model family, it's a custom licence — read it properly, including any linked acceptable-use policy.
4. Check per model, not per app. As our own lineup shows, tiers inside one product can differ.
5. Write down what you concluded. If you're using this commercially, a one-line note per model of which licence and when you checked will save you reconstructing it later.

If a tool won't tell you which base model it's running, that's worth noticing on its own. You can't evaluate a licence you can't identify.