# What Does Open Mean in Open AI Models?

by [kirupa](https://www.kirupa.com/me/index.htm) | filed under [AI Fundamentals](https://www.kirupa.com/ai_fundamentals/index.htm)

Crumb & Co.'s owner has been reading about AI, and one word keeps coming up: ***open***. Open models, open weights, open source AI. The pitch sounds great. Instead of sending every customer's message to an AI company's servers, the bakery could download a model and run Biscuit, our help desk bot, on its own computer. No per-token bill from a provider, and no customer messages leaving the building.

Then she hits a confusing headline about OpenAI, a company whose best-known models you can't download at all, and starts to wonder what the word actually means. That's a fair question. ***Open*** gets attached to models that share very different amounts of themselves, under licenses that range from almost anything goes to a long list of rules. In this article, we'll take a model apart to see which pieces can be shared, look at the difference between open weights and open source, read a couple of real licenses, and weigh what the bakery would gain and give up by running an open model itself. And yes, we'll sort out the OpenAI thing too.

Onwards!

## What a Model Is Made Of

As we saw in [What Exactly Is an LLM?](https://www.kirupa.com/ai_fundamentals/what_is_an_llm.htm), a model is mostly a giant pile of numbers called weights. But the weights didn't appear out of nowhere. Something produced them, and something has to run them. When people argue about how open a model is, they're really asking which of these pieces got shared:

![Five pieces make up a model. The weights are the billions of trained numbers at the model's core. The code to run it loads the weights and writes replies. The training code is the recipe that turned the data into weights. The training data is everything the model learned from. The license says what you're allowed to do with all of it.](https://www.kirupa.com/ai_fundamentals/images/what_open_means_in_ai_models_parts.png)

A bakery analogy helps here. The weights are like a finished loaf of bread. You can eat it, slice it, and even toast it with jam, but holding the loaf doesn't tell you the recipe or where the flour came from. The training code is the recipe, and the training data is the pantry. The license is the note taped to the bag that says whether you're allowed to resell the bread.

## Closed, Open Weights, and Fully Open

With those pieces in mind, most models land in one of three groups. Here is what each one shares:

![Three kinds of model. Closed models like GPT-5, Claude, and Gemini don't share their weights, training data, or training code. Open-weight models like Llama, Qwen, DeepSeek-R1, and gpt-oss let anyone download the weights, but don't share their training data or training code. Fully open models like OLMo 2 share all three.](https://www.kirupa.com/ai_fundamentals/images/what_open_means_in_ai_models_spectrum.png)

**Closed models** are the ones Biscuit has been using all along. We send a request to the company's API, the model runs on their computers, and a reply comes back. We never get the weights.

**Open-weight models** let anyone download the weights and run them. That's what most people mean when they say ***open model*** today, and it covers Meta's Llama, Alibaba's Qwen, DeepSeek-R1, Mistral's models, and more. The training data and the full training code usually stay private, though the companies often publish a paper or model card describing the general approach.

**Fully open models** share everything. [Ai2's OLMo 2](https://allenai.org/blog/olmo2), released in November 2024, comes with its weights, its training data, its training code, and even the logs from training. Fully open models are rarer, because sharing the data takes a lot of extra work, and companies often treat their data mix as a competitive secret (or as a legal headache, given the copyright fights we saw in [What Exactly Is an LLM?](https://www.kirupa.com/ai_fundamentals/what_is_an_llm.htm)).

## Open Weights vs. Open Source

Here's where the words get slippery. In software, ***open source*** has a specific meaning. The source code is shared under a license that lets anyone use, study, change, and share the program. Weights don't fit neatly into that picture. A loose but useful comparison is that weights are like a compiled app, the finished result, rather than the code that produced it:

![Two pipelines side by side. In open source software, source code is compiled into an app. For an AI model, training data and training code go through weeks of training on many GPUs to produce the weights. A handwritten note points at the weights: open weights share only this!](https://www.kirupa.com/ai_fundamentals/images/what_open_means_in_ai_models_source.png)

With open source software, we get the source code, so we can see exactly how the app was built and rebuild it ourselves. With open weights, we get only the result. We can't rebuild the model, because we don't have its data or its full recipe, and even if we did, retraining it would take a data center (as we saw in [Why Training Takes a Data Center](https://www.kirupa.com/ai_fundamentals/data_centers_and_training.htm)).

The Open Source Initiative (OSI), the nonprofit that maintains the definition of open source software, tackled this in October 2024 with its [Open Source AI Definition 1.0](https://opensource.org/ai/open-source-ai-definition). It keeps the four familiar freedoms (use, study, modify, and share) and says that exercising them requires three things: the parameters (the weights), "the complete source code used to train and run the system", and detailed information about the training data, enough that "a skilled person can build a substantially equivalent system". Notice that it asks for detailed information about the data rather than the data itself, since some data can't legally be shared. Weights alone don't qualify. Under this definition, most models people call open are open weights, not open source.

## Reading the License

Even among open-weight models, what we're allowed to do varies a lot, and the license is where that gets decided. Some models use standard software licenses that put very few strings on us. Others use custom licenses written just for that model. Here is a sample of well-known open-weight models at the time of writing:

| Model | From | Released | License |
|---|---|---|---|
| [OLMo 2](https://allenai.org/blog/olmo2) | Ai2 | November 2024 | Apache 2.0, with training data and code |
| [DeepSeek-R1](https://huggingface.co/deepseek-ai/DeepSeek-R1) | DeepSeek | January 2025 | MIT |
| [Mistral Small 3](https://mistral.ai/news/mistral-small-3) | Mistral AI | January 2025 | Apache 2.0 |
| [Gemma 3](https://ai.google.dev/gemma/terms) | Google | March 2025 | Gemma Terms of Use, plus a Prohibited Use Policy |
| [Llama 4](https://www.llama.com/llama4/license/) | Meta | April 2025 | Llama 4 Community License, plus an Acceptable Use Policy |
| [Qwen3](https://qwenlm.github.io/blog/qwen3/) | Alibaba | April 2025 | Apache 2.0 |
| [gpt-oss](https://openai.com/index/introducing-gpt-oss/) | OpenAI | August 2025 | Apache 2.0, plus a usage policy |

MIT and Apache 2.0 are long-standing open source software licenses. They let us use, change, and share the model for nearly anything, including commercial products, as long as we keep the copyright and license notices. Apache 2.0 also spells out a patent license. For Crumb & Co., any of those would be easy to say yes to.

Custom licenses are where we need to read carefully. Meta's Llama license is the best-known example. It lets us use, copy, change, and share Llama for free, with some conditions attached. Here is what the [Llama 4 Community License](https://www.llama.com/llama4/license/) asks for:

![Four conditions from the Llama 4 Community License. If your products had over 700 million monthly users, you must ask Meta for a license first. You must follow Meta's Acceptable Use Policy. You must show Built with Llama wherever you share it. And a model built from it must have a name that starts with Llama.](https://www.kirupa.com/ai_fundamentals/images/what_open_means_in_ai_models_llama.png)

The 700 million user line won't trouble a neighborhood bakery. It applies to companies whose products had more than 700 million monthly active users "on the Llama 4 version release date", which is a short list of very large companies. The Acceptable Use Policy bans a long list of harmful uses, and it contains a surprise for the multimodal Llama 4 models (the ones that understand images):

> With respect to any multimodal models included in Llama 4, the rights granted under Section 1(a) of the Llama 4 Community License Agreement are not being granted to you if you are an individual domiciled in, or a company with a principal place of business in, the European Union.
>
> [Meta, Llama 4 Acceptable Use Policy](https://github.com/meta-llama/llama-models/blob/main/models/llama4/USE_POLICY.md)

That restriction doesn't apply to people using a product built on those models. Because of conditions like these, the OSI has said that [Meta's Llama license is still not Open Source](https://opensource.org/blog/metas-llama-license-is-still-not-open-source). Meta's own [Llama 4 announcement](https://ai.meta.com/blog/llama-4-multimodal-intelligence/) uses both words, calling the models open-weight and the release part of its "commitment to open source", so we'll see both labels out in the wild.

None of this makes Llama bad or Apache 2.0 good. They're different deals. What it means for the bakery is that ***open*** on a model's page is a starting point, and the license is the real answer.

## What Open Weights Let Us Do

So what does the bakery actually get by downloading weights? The biggest change is where Biscuit's conversations go. Here is the difference:

![Two setups for Biscuit. With a closed model through an API, a customer's message goes from the customer to the bakery's website and on to the AI provider's servers. With an open-weight model on the bakery's own server, the message goes from the customer to the website and to a GPU server the bakery runs, holding the downloaded weights.](https://www.kirupa.com/ai_fundamentals/images/what_open_means_in_ai_models_hosting.png)

With weights in hand, a few things open up:

- We can run it ourselves. Customer messages stay on hardware we control, and nobody can retire the model out from under us. The model we tested last month is the exact model we run today.
- We can fine-tune it, training the model further on our own examples (the approach covered in [Prompting vs. Fine-Tuning](https://www.kirupa.com/ai_fundamentals/prompting_vs_fine_tuning.htm)) without depending on a provider to offer that service.
- We can shrink it by storing each weight in fewer bytes, so the model fits on smaller hardware. That trick is called [quantization](https://www.kirupa.com/ai_fundamentals/quantization.htm), and it trades a little quality for a lot of memory.
- We can look inside. Researchers can watch the numbers inside the model as it works, which isn't possible through an API. With gpt-oss, OpenAI also gives developers the [full chain of thought](https://huggingface.co/openai/gpt-oss-120b), the hidden thinking we met in [What Does It Mean for AI to Reason?](https://www.kirupa.com/ai_fundamentals/what_ai_reasoning_means.htm)

## What Open Weights Cost Us

The download is free. Everything after it isn't. A model needs enough fast memory to hold its weights, and the big ones need serious hardware. OpenAI says [gpt-oss-120b fits on a single 80GB GPU](https://huggingface.co/openai/gpt-oss-120b), a data center card, while the smaller gpt-oss-20b runs within 16GB of memory. Someone at the bakery now has to buy or rent that hardware, keep it running, handle the busy Saturday morning rush, and swap in newer models when they come out. A provider's API does all of that for us, and that convenience is a big part of what we pay for.

Here is who does that work in each case:

![With a provider's API, the provider handles the hardware, keeps the model running, handles busy times, and upgrades the model, and that convenience is a big part of what we pay for. With open weights, someone at the bakery has to buy or rent the hardware, keep it running, handle the busy Saturday morning rush, and swap in newer models when they come out.](https://www.kirupa.com/ai_fundamentals/images/what_open_means_in_ai_models_who_runs_it.png)

Safety works differently too. A provider can watch for misuse and change its model's behavior at any time. Once weights are downloaded, nobody can take them back, and the safety training baked into them can be trained right back out. In 2023, [Simon Lermen and colleagues](https://arxiv.org/abs/2310.20624) reported that "with a budget of less than $200 and using only one GPU", they undid the safety training of Meta's Llama 2-Chat models. Labs know this. Before releasing gpt-oss, OpenAI's [safety paper](https://cdn.openai.com/pdf/231bf018-659a-494d-976c-2efdfc72b652/oai_gpt-oss_Model_Safety.pdf) describes fine-tuning the model itself to estimate the worst-case harm someone could get out of it.

Finally, open isn't the same as transparent. Here is what a weights file can and can't tell us:

![A downloaded weights file is a long list of decimal numbers like 0.0132, -0.4471, and 0.2208. With it, we can run the model on our own hardware and fine-tune it on our menu. The numbers alone can't tell us what text the model was trained on or why it gave a particular answer.](https://www.kirupa.com/ai_fundamentals/images/what_open_means_in_ai_models_inside.png)

A file full of numbers doesn't come with an ingredient list. If the training data isn't published, we can't check whether it included our competitor's website, copyrighted books, or anything else. And the weights don't explain the model's behavior any more than a closed model's do. They just let us run it.

## Wait, What About OpenAI?

Now for the name. OpenAI is a company, and the ***Open*** in its name doesn't describe the license of any particular model. It started in December 2015 as a nonprofit research lab, and its [founding announcement](https://openai.com/index/introducing-openai/) said "As a non-profit, our aim is to build value for everyone rather than shareholders". Here is how its models have been released since then:

![A timeline. In 2015, OpenAI is founded as a nonprofit. In 2019, GPT-2's weights are released, marked open weights. In 2020, GPT-3 is offered through an API, marked closed. In 2023, GPT-4 arrives in the API and ChatGPT, marked closed. In 2025, gpt-oss ships under Apache 2.0, marked open weights.](https://www.kirupa.com/ai_fundamentals/images/what_open_means_in_ai_models_openai.png)

OpenAI released GPT-2 in stages during 2019 and published [the full model's weights](https://openai.com/index/gpt-2-1-5b-release/) that November. Its flagship models since then, from GPT-3 through the GPT models behind ChatGPT today, have been closed, available only through its apps and API. Then in August 2025, it released gpt-oss-120b and gpt-oss-20b under Apache 2.0, and [said](https://openai.com/index/introducing-gpt-oss/) they were "our first open-weight language models since GPT-2". So OpenAI makes both kinds. Its name tells us nothing about which kind a given model is. The model's page and license do.

## Conclusion

When a model is called open, it helps to ask what was actually shared. Most of the time, it's the weights: the finished loaf, ready to run on our own hardware, but without the recipe or the pantry. Fully open models like OLMo 2 share the training code and the data itself, which goes beyond the detailed data information the OSI's definition of open source AI asks for. And whatever got shared, the license decides what we're allowed to do with it, from Apache 2.0 and MIT's very few strings to custom licenses like Llama's with rules of their own.

For Crumb & Co., open weights would mean customer messages stay in-house and the model never changes without the bakery's say-so. It would also mean buying and babysitting a GPU server, and owning every safety decision a provider used to make. Neither choice is right for everyone. It's a trade, and now the owner knows which questions to ask.

Open weights also let us see how models are built on the inside, and a download page is full of hints, with names like Qwen3-235B-A22B and Llama-4-Maverick-17B-128E. What those names tell us is where we're going next in [Types of AI Models](https://www.kirupa.com/ai_fundamentals/types_of_ai_models.htm).