What Are Open Model Weights? Open Weights vs Open Source, and How to Use Them

In Where Do a Model's Weights Come From? I trained a tiny model from random numbers to show where weights are born. This article is about the other end: when someone gives their weights away. You've seen the headlines: "Meta releases Llama", "Qwen is open", "OpenAI publishes an open-weight model". What do you actually get, what are you allowed to do with it, and how do you run it?

Funny detail first. I asked a small open model running on my Mac, "In one sentence: what are open model weights?" It answered:

Open model weights refer to the publicly available source code and parameters of machine learning models, allowing researchers and developers to inspect, modify, and retrain the underlying algorithms without paying licensing fees.

That's wrong twice: weights are not source code, and licences very much apply. It's also the most common misunderstanding about open models, so let's untangle it.

Weights are the model

A trained model is two things: an architecture (the recipe: how many layers, how they connect) and the weights (the billions of numbers learned during training, stored as tensors). The architecture is a few pages of code that everyone already has. The weights are what cost millions of dollars of compute.

So "releasing a model" almost always means publishing the weights file. With it, you can run the model on your own hardware, offline, as many times as you want.

Three levels of "open"

Level	What you get	Examples
Closed	An API. You send text and get text back; the weights never leave the company.	GPT-5, Claude, Gemini
Open weights	The weights file, plus a licence that says what you may do with it. Not the training data, usually not the training code.	Qwen, Gemma, Llama, Mistral, Phi, gpt-oss, DeepSeek
Fully open	Weights and the training data and the code to train them, so someone else could rebuild the model.	OLMo (AI2)

The Open Source Initiative made the third level official in its Open Source AI Definition 1.0. To count as open source AI, a system has to provide three things under open terms: the parameters (weights), the complete code used to train and run it, and enough data information that a skilled person could build a substantially equivalent system. Most "open" models stop at the first one.

The analogy that works for me, as a .NET developer: open weights are like a compiled program, open source is like its source code. With the weights you can run the model, inspect it, and even patch it (fine-tuning). But you can't rebuild it, because you don't have what it was built from: the training data and the training pipeline. It's the same difference I wrote about in decompiling and recompiling .NET apps: having the binary isn't having the source.

"Open" doesn't mean "no licence"

Every open model comes with a licence, and they're not all the same. Here's what each model declares on Hugging Face (checked 19 October 2026):

Model	Licence	What that means in practice
Qwen3.5	Apache 2.0	use, modify, sell; keep the notices
Gemma 4	Apache 2.0	same
gpt-oss (OpenAI)	Apache 2.0	same
Mistral 7B v0.3	Apache 2.0	same
Phi-4 (Microsoft)	MIT	even simpler permissive licence
OLMo 2 (AI2)	Apache 2.0	and the training data and code are published too
Llama 3.1 (Meta)	Llama 3.1 Community License	you must request access first, and companies with more than 700 million monthly active users need a separate licence from Meta

Apache 2.0 and MIT are classic open-source software licences: permissive, commercial use allowed. The Llama licence is a custom one with its own conditions. And some smaller vendors go further: I've seen model licences that are free only below a certain company revenue. Read the licence before you build on a model, exactly as you would for a library.

What's actually in the download

Here's what I got when I downloaded Qwen3.5-2B (the 4-bit version for Apple's MLX) from Hugging Face:

File	Size	What it is
`model.safetensors`	1.72 GB	the weights
`config.json`	3 KB	the architecture: 24 layers, 2,048 numbers per token, 248,320-token vocabulary
`tokenizer.json`	20 MB	the tokenizer: how text becomes token ids
`chat_template.jinja`	8 KB	how to format a conversation so the model understands who's speaking
`README.md`	1 KB	the model card, with the licence

The weights are about 98% of the download. The rest is instructions for using them.

You'll meet two file formats:

.safetensors: Hugging Face's format, used by PyTorch, MLX and most tools. Often split into several files for big models.
.gguf: a single file used by llama.cpp, Ollama and LM Studio, usually already quantized (for example Q4_K_M, about 4 bits per number).

Opening a weights file with ten lines of Python

A .safetensors file is refreshingly simple: 8 bytes saying how long the header is, a JSON header listing every tensor, then the raw numbers. You don't need any AI library to look inside:

import json, struct

with open("model.safetensors", "rb") as f:
    n = struct.unpack("<Q", f.read(8))[0]          # first 8 bytes: length of the JSON header
    header = json.loads(f.read(n))
header.pop("__metadata__", None)
print(len(header), "tensors")
for name in list(header)[:3]:
    print(name, header[name]["dtype"], header[name]["shape"])

991 tensors
language_model.model.embed_tokens.biases BF16 [248320, 32]
language_model.model.embed_tokens.scales BF16 [248320, 32]
language_model.model.embed_tokens.weight U32 [248320, 256]

That's the model, laid bare: 991 named tensors. The first one is the embedding table, one row per token in the vocabulary, 248,320 of them. Because this is the 4-bit version, each row's 2,048 numbers are packed eight per 32-bit integer (256 × 8 = 2,048), with a scale and an offset for every group of 64 numbers. That's what quantization looks like on disk: the same weights, squeezed to a quarter of the size.

How to use open weights: three ways

1. An app. LM Studio and Ollama let you search, download and chat with open models without writing code. This is where to start.

2. One command. With Ollama installed:

ollama run qwen3:4b-instruct "In one sentence: what are open model weights?"

Open model weights refer to the public sharing of the parameters (weights) of machine learning models,
allowing others to use, modify, and build upon them without needing to train the model from scratch.

The bigger 4B model gets it right. (Ollama samples with some randomness by default, so you may get a different sentence each time.)

3. Code. On a Mac, Apple's MLX; on an NVIDIA GPU, Hugging Face transformers or llama.cpp. This is the script that produced the wrong answer at the top of this article:

from mlx_lm import load, generate

model, tokenizer = load("mlx-community/Qwen3.5-2B-4bit")   # downloads once, then runs offline
messages = [{"role": "user", "content": "In one sentence: what are open model weights?"}]
prompt = tokenizer.apply_chat_template(messages, add_generation_prompt=True, enable_thinking=False)
print(generate(model, tokenizer, prompt=prompt, max_tokens=80, verbose=True))

On my Mac Studio (M1 Max) it wrote 188 tokens per second using 1.2 GB of memory. A 2-billion-parameter model, running locally, faster than you can read.

What open weights let you do

Run offline and private. Nothing leaves your machine. That's the whole premise of my offline tutor for El Salvador: a model on a laptop with no internet.
Fine-tune. Start from someone else's weights and teach them something new. With LoRA you only train a thin layer on top; that's how I taught a 1.5B model a language that didn't exist.
Shrink them. Quantize to 4 bits and a model fits on a laptop or a phone.
Inspect them. As above: every tensor is there to read.
Pay nothing per token. You pay for your hardware and electricity instead.

What they don't give you, usually: the training data (so you can't fully know what the model learned, or reproduce it), and any guarantee the model is right. My 2B model was confidently wrong about its own nature.

A checklist before you use an open model

Licence: Apache 2.0 or MIT, or a custom one with conditions?
Access: free download, or gated behind an agreement?
Size: does the quantized file fit your RAM or GPU memory, with room to spare?
Format: .safetensors for PyTorch and MLX, .gguf for llama.cpp, Ollama and LM Studio.
Chat template: use the one that ships with the model, or it will answer badly.
Test it on your own task, not on someone else's benchmark.

How much to trust this

Licences change and vary by version. I checked what each model declares on Hugging Face on 19 October 2026; always read the licence file of the exact version you download.
One question, two small models, one Mac. The answers and speeds illustrate the point; they're not a benchmark.

The one-line mental model

Open weights are the compiled model: free to download, run, inspect and fine-tune, under a licence you should read. Open source AI is the whole build: weights, code and data. Most "open" models give you the first, not the second.