Key Takeaways
Open weights provide downloadable model parameters, while open-source AI emphasizes broader transparency.
Training code and data information help developers understand and reproduce AI models.
Licensing matters: Commercial use and restrictions vary by model.
Privacy and security remain important when deploying models independently.
Evaluate before deployment by checking licenses, security, and real-world performance.
Downloading an AI model is easy. Knowing what you're allowed to do with it, and what you still can't see, is the hard part.
Picture a small team building a customer support chatbot. They find a free AI model online, Alibaba's Qwen2.5-3B, download it, and train it further on a few thousand of their old support tickets so it learns their product. It works surprisingly well. The demo goes great, and a launch date is set.
A week before launch, someone finally reads the license. This version of Qwen is licensed for non-commercial purposes only (license). Its slightly bigger sibling, Qwen2.5-7B, uses Apache 2.0, a standard license that allows business use (model card). The biggest, Qwen2.5-72B, uses a third license, which, among other rules, makes products with more than 100 million monthly users ask permission first. Same family, same release day, three different rule books.
Nothing stopped the download. That's the whole problem in one story. Being able to download an AI model and being allowed to build a business on it are two separate questions, and "open" gets used for both.
In 60 seconds
Open weights means you can download the finished model. It says nothing about what you're allowed to do with it, or how it was made.
Open source AI, by the Open Source Initiative's definition, also shares the code used to build the model and a detailed description of its training data.
The rules change from model to model, even within one company.
Running a model yourself keeps your data in-house, but makes security your job.
What you actually get when a model is "released"
Think of an AI model as a cake. The weights are the finished cake: billions of numbers the model learned during training, packed into files you can download. With the cake you can serve it, slice it, or add your own frosting, which in AI terms means running the model and fine-tuning it on your own data.
What the cake doesn't come with is the recipe. That would be the training code (the instructions used to build the model), the training data (the ingredients), and the tests used to check it. Then there's the license: the rules about whether you're allowed to sell slices.
Different companies put different things in the box. OpenAI's gpt-oss-120b, released in August 2025, comes with its weights and the code to run it, but its training data gets only a short description. Ai2's Olmo 3, from November 2025, also publishes its training data, training code, test tools and snapshots saved partway through training (Ai2). Both are useful. Only one lets you check how it was made.
What comes with an AI model?
Piece | Paid AI service (typical) | Open weights: gpt-oss-120b | Fully open: Olmo 3 |
|---|---|---|---|
The trained model (weights) [The finished "cake"] | Not shared | Shared (Apache 2.0) | Shared (Apache 2.0) |
Model blueprint [How it is put together] | Described at most | Shared | Shared |
Code to run it | Not shared | Shared | Shared |
Code used to train it [Part of the recipe] | Not shared | Not shared | Shared |
Training data [The ingredients] | Not shared | Not shared | Shared (Dolma 3) |
Description of the data | Brief at most | A short paragraph | Shared in detail |
Test tools and results | Results only | Results only | Shared |
Snapshots from training | Not shared | Not shared | Shared |
License (rules of use) | Terms of service | Apache 2.0 + usage policy | Apache 2.0 |
The gpt-oss-120b and Olmo 3 columns show what OpenAI and Ai2 published with those specific releases (gpt-oss model card; Ai2 Olmo 3). The paid-service column is a general picture of a typical service, not any single company.
What "open source" means, according to the OSI
There is a widely recognized answer. The Open Source Initiative (OSI), the nonprofit that maintains the definition of open source software, published the Open Source AI Definition 1.0 in October 2024. It says a truly open source AI must give everyone four freedoms: to use it for any purpose without asking permission, to study how it works, to change it, and to share it, changed or not.
To make those freedoms real, you need three things: the weights, the complete code used to train and run the model, and a description of the training data detailed enough that a skilled person can build a substantially equivalent system. That doesn't mean every document has to be published. Private data, like personal information, can be described instead of shared. But weights on their own don't qualify.
The four freedoms
Freedom | What it means |
|---|---|
Use | For any purpose, without asking permission |
Study | See how it works and inspect its parts |
Change | For any purpose, including changing its answers |
Share | With anyone, changed or unchanged |
A plain-language summary of the OSI Open Source AI Definition 1.0.
The three ingredients you need for those freedoms
Ingredient | What the definition asks for |
|---|---|
Data information | Enough detail about the training data that "a skilled person can build a substantially equivalent system." Open data must be shared, public data must say where to find it, data sold by others must be listed, and private data (like personal information) must be described but not handed over. |
Code | The complete code used to prepare the data, train the model, test it and run it, under an approved open source license. |
Weights | The trained model itself, on open terms. Weights alone are not enough: they must come with the data information and code used to make them. |
From the OSI definition. The four kinds of data come from the OSI's FAQ.
When the OSI tested real models against its draft, EleutherAI's Pythia and Ai2's OLMo passed, while Meta's Llama 2 and Microsoft's Phi-2 did not. Outside the OSI, companies use these words loosely. So when someone calls a model open, ask which parts.
What you can do with just the weights
Quite a lot. Free tools like Ollama and llama.cpp let you run a model on your own computer, with no internet connection needed once it's downloaded. A technique called quantization shrinks models by storing each number less precisely, a bit like compressing a photo: smaller file, slightly lower quality. That's how OpenAI's gpt-oss-20b runs on a machine with 16 GB of memory. Customizing a model is within reach, too: a method called QLoRA fine-tuned a 65-billion-parameter model on a single 48 GB graphics card.
What can run it?
Example model | Full size | Shrunk to a quarter | What can run the shrunk version |
|---|---|---|---|
Small: Qwen2.5-3B 3 billion parameters | 6 GB | 1.5 GB | A typical laptop |
Medium: Phi-4 14 billion parameters | 28 GB | 7 GB | A laptop with 16 GB of memory |
Large: Llama 3.3 70B 70 billion parameters | 140 GB | 35 GB | A high-end workstation or a data-center graphics card |
Rough memory needed just to load each model, worked out from its size. Running it takes some extra memory on top, and shrinking costs a little quality. Sizes come from each model's official page.
What you can't do is look inside the kitchen. Meta's Llama 3.1 model card says it learned from ~15 trillion tokens of data from publicly available sources (model card). (Tokens are small chunks of text.) Meta's technical report adds a rough breakdown by topic, but the data itself isn't released (Llama 3 paper). You can't check whether a test the model aces was in its training data, like a student who saw the exam in advance. And when it gets something wrong, you can't trace the mistake back to where it came from.
The license decides what you're allowed to do
Some models use standard software licenses. Apache 2.0 and MIT both let you use, change, share and sell the model, as long as you keep the original copyright notices. Apache 2.0 also includes a patent license from the people who contributed to it. Gemma 4, gpt-oss, Phi-4, Qwen3 and IBM's Granite 4.0 all use one of these two.
Others use a company's own license, and these come with strings attached. Meta's Llama 3.1 license allows business use, but companies whose products had more than 700 million monthly users on its release date must ask Meta first. If you ship it in a product, you also have to display "Built with Llama," and every user must follow Meta's acceptable use policy. Llama 4's models all understand images, and for those, Meta's policy doesn't grant rights to people or companies based in the EU, though anyone can still use products built with them (policy). Google's Gemma 3 terms carry their banned uses into any modified version, and Google reserves the right to restrict (remotely or otherwise) usage it believes breaks the rules. Mistral's Devstral 2 coding model isn't licensed to companies earning more than $20 million a month (license).
The rules also change from one release to the next. Gemma 4 moved to Apache 2.0 in April 2026 (Google). Mistral Large 3 did the same after Large 2 was research-only (Mistral). Meta's Muse Glimmer 30B, released in August 2026, is Apache 2.0 too, unlike every Llama model before it. So never guess a license from the company name.
What each model's license allows
Model | License | Business use | Key rules |
|---|---|---|---|
Olmo 3 - Ai2 | Apache 2.0 | Allowed | Keep the license and notices. Training data and code are public too. |
gpt-oss-120b / 20b - OpenAI | Apache 2.0 + usage policy | Allowed | A short usage policy asks you to "comply with all applicable law." |
Llama 3.1 - Meta | Llama 3.1 Community License | Allowed, with conditions | Over 700 million monthly users on the release date: ask Meta first. If you ship it, show "Built with Llama." Shared models trained with it must start their names with "Llama." |
Gemma 3 -Google | Gemma Terms of Use | Allowed, with rules | Banned uses carry over to modified copies. Google can restrict use it believes breaks the rules. |
Gemma 4 -Google | Apache 2.0 | Allowed | The first Gemma under a standard license. Same company, new rules. |
Qwen2.5-3B - Alibaba | Qwen Research License | Non-commercial | Research or testing only. |
Qwen2.5-7B -Alibaba | Apache 2.0 | Allowed | Same family and release day as the 3B, different rules. |
Devstral 2 - Mistral AI | Modified MIT | Revenue limit | No rights for companies earning more than $20 million a month. |
How to check a license in two minutes
Open the model's page on Hugging Face and find the license tag near the top.
Open the LICENSE file and search it for "commercial," "monthly active users" and "revenue."
Look for a separate usage policy, and read that too.
Save a copy, and note the exact model version you checked.
Running it yourself: more control, more responsibility
A big reason companies like downloadable models is privacy. When the model runs on your own computers or cloud account, your customers' messages never go to an outside AI company. For hospitals or banks, that can settle the decision.
Where your data goes, and who looks after it
Your own computers | Your cloud account | An AI company's service | |
|---|---|---|---|
Where messages go | Stay in your building | Stay in your cloud account | Go to the AI company |
Who runs the model | You | You | The AI company |
Your job | Hardware, updates, security fixes, access, protecting logs, fixing problems | Cloud servers, updates, security fixes, access, choosing the data region, fixing problems | Your app, what data you send, reading their data terms, coping with outages or changes |
Someone else's job | Model makers: the model and its license | Cloud company: the data centers. Model makers: the model and its license | AI company: computers, running the model, updates and storing your data per your contract |
But control isn't the same as safety. Your chat logs still hold sensitive data, and your servers still need locking down. Even model files can be risky: Hugging Face warns that a widely used file format can run hidden code when it's opened, which is why the safer "safetensors" format exists (Hugging Face). Once you run a model yourself, updates, security fixes and monitoring are all your job.
And seeing a model's weights doesn't make it trustworthy. Open models can make things up (AI people call this "hallucinating"), just like closed ones. Openness makes it possible to check a model. It doesn't do the checking for you.
So which kind should you choose?
Openness isn't automatically better. A paid AI service from a company like OpenAI or Google is the easiest place to start and often among the most capable, but you depend on their prices and rules, and your data goes to them. Open-weight models give you control and privacy in exchange for running your own hardware. Fully open models add the ability to inspect and rebuild, from a much smaller selection.
Paid service, open weights or fully open?
Paid AI service | Open-weight model | Fully open model | |
|---|---|---|---|
In short | Rent it | Own the cake | Own the recipe |
You get | Access over the internet, plus support | The trained model and code to run it | The model, its code and its data details |
Runs on | The AI company's computers | Your own hardware or cloud | Your own hardware or cloud |
Customize it? | Only in the ways the company offers | Yes, if the license allows | Yes, even rebuild it from scratch |
See how it was made? | Only what the company publishes | No, only how it behaves | Yes |
Costs | Pay as you go | Hardware plus the people to run it | Same as open weights, more to rebuild |
You depend on | The company's prices, rules and plans | The license and your own team | A smaller choice of models |
Not sure where your project stands?
Start with these six questions.
Question | What to do |
|---|---|
1. Have you read the license and model card for the exact version you plan to use? | Read them first. Rules can differ between sizes of the same model (Qwen2.5-3B vs 7B) or between versions (Gemma 3 vs 4). |
2. Does the license allow the way your business wants to use it? | Not sure: ask a lawyer to look at the specific rules. No: ask the maker for a business license, or pick another model. |
3. Will you share the model, or offer it inside a product or service? | If yes, follow the sharing rules: include the license, keep the notices, and add any required credit, like "Built with Llama." Some licenses, including Llama's, count offering it in a product as sharing. |
4. Do you need to show what data the model learned from? | If yes, downloadable weights won't be enough. Look at fully open models that publish their data and code, like Olmo 3 or Pythia. |
5. Does your team have the skills to run and secure its own AI servers? | Consider a paid service, or a company that hosts the open model for you. Either way, read how they handle your data. |
6. Have you tested the model on your own real examples? | Test accuracy, safety, speed and cost before you commit. Public leaderboards aren't enough. |
A starting point, not a replacement for legal or security advice. Whatever you choose, note the exact model version and save a copy of its license.
Conclusion
Open weights and open source AI aren't two names for the same thing. Open weights give you the finished cake: you can run the model, shrink it and customize it, within whatever rules its license sets. Open source AI, as the OSI defines it, also gives you the recipe: the code that built the model and enough detail about its data to build something similar. Well-known "open" models like Llama, Gemma and gpt-oss are the first kind.
Neither is automatically the better choice. What matters is knowing which one you have. Before you build on a model, check what parts you actually get, what the license allows for that exact version, and what you still can't see. Those answers tell you far more than the word "open."
Q1. What is the difference between open weights and open-source AI?
Open-weight AI provides downloadable model parameters, while open-source AI emphasizes broader transparency, including training code and data information. This affects transparency, customization, and reproducibility.
Q2. Can open-weight AI models be used for commercial purposes?
Yes, some models allow commercial use, while others impose restrictions based on revenue, user numbers, or intended use. Always check the specific model license before deployment.
Q3. Is open-source AI more transparent than open-weight AI?
Generally, yes. Open-source AI provides broader access to code, model parameters, and training-data information, while open-weight models may keep their training processes undisclosed.
Q4. What are the risks of using open-weight AI models in production?
Risks include restrictive licenses, security vulnerabilities, hallucinations, and infrastructure maintenance. Teams should review licensing, protect sensitive data, and test performance before deployment.
Q5. How can I check whether an AI model license allows commercial use?
Review the model card, official license, and usage policy for commercial restrictions, attribution requirements, and revenue limits. Verify the exact model version and seek legal advice when necessary.
