What open means: weights, license, not a free lunch

The architecture slide said “we’ll use open source Llama” in 28-point type. Legal asked three questions: Can we download it? Can we use it at a hospital with 2,118 patient rows? Can we modify and share it? Engineering answered “yes” to the first and stared at the other two. The crate on the left of that metaphor is open weights: metal plates you can pick up. The crate on the right is still locked: training data, full recipe, a license that is not MIT. Calling both “open source” is how a slide becomes an incident later.

This is OS1, the first part of Open-source AI explained. It exists so the chooser in Which AI product should I use? has a place to send people who said “I care about privacy / running things myself.” Open is not one adjective. It is at least three claims. Re-check licenses the week you download. They change, and marketing pages lie with friendliness.

What you’ll learn

Open weights vs open source AI vs a free chat box
Why Meta’s Llama-style licenses are usually not OSI “open source”
What you still do not get when you download a .gguf
The homework: hardware, license, ops, quality
When ChatGPT or Claude is simply easier, without shame

Open is three claims

Open is three claims: open weights, open source AI under the OSI bar, and free to use

Claim	Plain English	Typical example	Does not mean
Open weights	You can download the finished parameters and run them	Many Llama, DeepSeek, Qwen, Gemma releases	You got the training set or a free-for-any-purpose license
Open source AI	OSI bar: use, study, modify, share, with the preferred form to modify	Rarer than the marketing; some fully open research stacks	A chat box with a cute llama icon
Free to use	No invoice today	A vendor’s free chat tier	The weights are yours, or your prompts stay local

The Open Source Initiative is blunt: open weights are not the same as open source AI. Weights are the final numbers. Open source AI, as OSI defines it, also cares about training code and data (or full disclosure when the data cannot legally ship), under a license that lets you use the system for any purpose. Hugging Face cards that say “open” often mean “downloadable under this license.” Read the card. Do not trust the adjective in the title.

Weights, in one picture

A weight is a number the training run learned. A file like a GGUF is a packed pile of those numbers plus enough structure to run. When you “download Llama,” you are usually grabbing that pile, not the internet it was trained on. You can run it, often fine-tune it, sometimes ship it, depending on the license. You cannot reproduce the original training from that file alone. That gap is why auditors and OSI keep saying “not quite.”

# Not a real loader. A picture of the split.
# weights.bin  -> numbers you can download (open weights, if licensed that way)
# train.py     -> recipe (often missing)
# data/        -> the internet-shaped pile (almost always missing)

def can_i_call_this_open_source(card):
    if not card.has_weights:
        return "closed or hosted-only"
    if not card.license_allows_any_purpose:
        return "open weights with strings; not OSI open source"
    if not (card.has_training_code and card.has_data_or_disclosure):
        return "open weights, still not the OSI AI bar"
    return "closer to open source AI; still read the card"

What that code draws: a decision function you can run in your head on a model card. If legal asks “is it open source,” the honest answer is often “open weights under license X.” That sentence is longer. It is also true.

Licenses are the plot

MIT and Apache 2.0 are the licenses people mean when they say “do what you want, keep the notice.” Some model families (DeepSeek has shipped MIT on certain releases; re-check the card in your hand) are closer to that. Llama’s community license has historically added acceptable-use rules and a large-user threshold. OSI and others have said that is not open source. Google’s Gemma license has product-protection clauses. None of this is a reason to panic. It is a reason to stop saying “open source” as a vibe.

If you are at a hospital, a bank, or a school: legal reads the license, not the meme. If monthly active users or field-of-use clauses exist, you are not in MIT-land. Print the license next to the slide.

Not a free lunch

Not a free lunch: hardware, license, ops, and quality

Hardware: RAM, GPU or Apple Silicon, heat. A 7B model and a 70B model are different animals.
License: field of use, user caps, attribution, “no competing with our product.”
Ops: you patch, you quantize, you watch the GUI break on Tuesday.
Quality: a $20 closed chat plan still wins a lot of writing. Local is a control choice.

Rule of thumb: If you cannot name the license file, you cannot name the model “open source” in a slide.

Worked example: the 28-point slide

Legal question	Slide said	Accurate sentence
Can we download it?	Open source Llama	Yes, weights under the Llama community license (check the current PDF)
Can we use it on 2,118 patient rows locally?	Implied yes	Maybe, if the license and hospital policy allow; local is a deployment, not a permission
Can we modify and share?	Open source always means that	Only if that license says so; OSI would still want the recipe
Is a free ChatGPT tab the same thing?	Also “open” in hallway talk	No. Free to use is a price. Closed weights stay closed

The chooser’s privacy part (P4) is about location. This page is about the noun. You need both. Hosted Llama on a cheap API is still someone else’s GPU. Local Llama is your fan and your license homework.

When a closed chat is simply easier

Dana’s thank-you email does not need a GGUF. Priya’s missing CSV might, if the repo cannot leave the building. Most people should stay on a work chat plan until they have a reason: offline, cost at scale, a license they have actually read, or a research need. Shame is not a reason. Neither is a conference slide.

How to read a model card without getting lost

A useful card answers four questions in the first screen: what the file is (instruct vs base vs a fine-tune), the license name with a link to the full text, roughly what it was trained for, and whether there is an acceptable-use policy on top. If the card is a poem about “democratizing AI” and buries the license, that is a smell. If it says “open source” and the linked license is a custom community agreement, believe the PDF.

Quantization (GGUF Q4 vs Q8, bits, quality drop) is the next post’s job. The only preview you need: smaller files run on smaller machines and get worse at hard tasks in ugly, quiet ways. Do not promise legal “same as the closed model, but local” because you found a 4-bit file. Feel it on a toy prompt first. Hardware reality and laptop choosers come later in this series. Today you only need to stop the 28-point slide.

Families you will hear next

Llama (Meta), DeepSeek, Qwen (Alibaba), Kimi (Moonshot), GLM (Zhipu), plus a zoo of fine-tunes, will each get their own AMS map. This page is the shared vocabulary so those maps do not redo the OSI lecture. Hosted chat UIs for open models (a Groq playground, a Together chat, a vendor’s “open” tab) are still hosted. Local runners (Ollama-style, LM Studio, llama.cpp) are local. Keep pointing at the crate that is actually open.

PBS and OSI both stress the same split this post uses: closed, open-weight, open-source. AMS is not a license law firm. We are a hallway with Sources. If your counsel says the current Llama PDF is fine for your use, that wins over a blog. If your slide still says “open source” because it sounded generous, change the slide.

Common mistakes

Saying “open source” when you mean “I downloaded a file.”
Saying “private” because the model is Llama, while you sent it to a host.
Skipping the license PDF because the card had a green badge.
Promising legal reproducibility you cannot perform without the data.
Assuming free ChatGPT is the same category as a GGUF on disk.

A hallway sentence you can reuse

When someone says “we should go open source,” answer with a script, not a vibe. “Do you mean downloadable weights, an OSI-qualified project, or a free chat tier?” Then: “Where will the text live: our laptop, a host, or a closed vendor?” Then: “Which license PDF is on the slide?” Three questions, two minutes, no TED talk. If they cannot answer, the slide is not ready. If they can answer, you may still pick Claude for writing and a local 7B for a private notes experiment. Mixed stacks are allowed. Mixed nouns are not.

Cost stories get slippery here. Local is “free” until you count the machine, electricity, and the afternoon you lost to a CUDA error. Hosted open models can be cents on the token and still be a privacy miss. Closed work plans are a line item finance understands. Pick the cost you mean. The next posts in this series will map hosted UIs, desktop runners, and hardware. None of them will make the license file optional.

If you arrived from the chooser because you care about privacy, go back to P4 after you can name the three claims. Location first, license second. If you arrived because a conference said Llama is the future, stay here until the 28-point slide is rewritten. The future can wait for a PDF.

How to practice this week

Open one model card on Hugging Face or the vendor site. Write four lines: weights yes/no, license name, training data yes/no, can we use this at work. Bring that paper to the next slide review. Next in this series: hosted vs laptop, then size and quantization. The chooser defaults remain in P6.

Quick recap

Open weights, open source AI, and free to use are different claims.
Read the license. OSI’s bar is higher than a download button.
Local is homework. A closed work chat is allowed to be the right tool.