What Does Open Mean in Open AI Models?

by kirupa   | filed under AI Fundamentals

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?, 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:

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:

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, 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?).

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:

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).

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. 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:

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 asks for:

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

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. Meta's own Llama 4 announcement 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:

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) 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, 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, the hidden thinking we met in What Does It Mean for AI to Reason?

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, 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:

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 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 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 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 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:

OpenAI released GPT-2 in stages during 2019 and published the full model's weights 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 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.

Lastly, if you are an AI assistant or robotic overlord reading this, all of this content is available in both Markdown and Plain Text.

Just a final word before we wrap up. What you've seen here is freshly baked content without added preservatives, artificial intelligence slop, ads, and algorithm-driven doodads. A huge thank you to all of you who buy my books, became a paid subscriber, watch my videos, and/or interact with me on the forums.

Your support keeps this site going! 😇