AI TERMINOLOGY · FIELD GUIDE

Open Weights, Explained. A Guide to the Terms in the Open Models Letter

Every AI word in the letter, translated into plain English, with real numbers, runnable code, and the case studies that made these terms matter.

Thumbnail: Yesterday's Scripts Are Today's Agents

BY SHREYAS SANJAY JADHAV

~15 min read · Melbourne

IN THIS GUIDE
  1. The letter in three claims
  2. What a model actually is
  3. Open weights vs. open source
  4. Training vs. inference
  5. Distillation, with numbers
  6. MoE and quantization
  7. Safety, security, red teaming
  8. Sovereignty and lock-in
  9. Four case studies
  10. Try it yourself
  11. Glossary
  12. Sources

The letter in three claims

The open models letter, Open Weights and American AI Leadership (July 24, 2026), makes three claims. Each one depends on a technical term most readers skim past. This guide slows down on those terms.

CLAIM 1AI will transform every industry and be built by every country.
CLAIM 2Open models strengthen safety, cybersecurity, innovation and sovereignty.
CLAIM 3The world needs both frontier closed models and frontier open models.

You cannot judge a claim about "open" AI until you know what is actually open.

Relatable scenario
A closed model is a famous bakery sold through a window. You get excellent cake, but never the recipe, you cannot change the sugar, and if the bakery closes, your menu closes with it. Open weights are the finished recipe card with exact quantities. You can bake it in your own kitchen, adjust it for local tastes, and keep baking even if the famous bakery disappears.

What a model actually is

A neural network is a function with billions of adjustable knobs. Each knob is a parameter, stored as a weight: a floating-point number inside a matrix. Training nudges those numbers until predictions match examples. The weights are what remains afterwards: the learned knowledge, stored as numbers.

A model is a recipe with 117 billion knobs. The weights are the knob settings.

So "releasing weights" means publishing the trained result itself. Not a product, not an API, and not a description of the result.

Fig 1 · One layer, many weights
inputhiddenoutput Each line = 1 weight. This toy has 18. gpt-oss-120b has 117 billion.
Illustrative toy network. Open weights means publishing every line's value, not just the picture.

Open weights vs. open source

This is the most important distinction in the letter and the most misused phrase in AI. The Open Source Initiative (OSI) defines "open source" strictly. Many model releases fall short of that, which is why people say "open weights".

Fig 2 · The openness spectrum
Closed APIweights hidden Open weightslicence varies Open source (OSI)code + data + licence
Illustrative positioning. OpenAI describes gpt-oss as "open-weight" and not open source, because the OSI definition requires publishing training data.
TermWhat you getExample
Open weightsDownloadable trained parameters. Usage terms vary.Llama, Qwen, DeepSeek-R1 distills, gpt-oss
Open source (OSI)Code, and enough information to rebuild the work, under an approved licence.Linux, PyTorch
Closed modelAccess via API or app. No weights.Most frontier models sold as a service
Licence check: "Open" does not mean "free for any use". The OSI does not classify Llama as open source because of its commercial restrictions. gpt-oss uses Apache 2.0, a permissive licence. Read the licence before you build a product on any open model.
Relatable scenario
One friend shares the ingredient list. Another shares the ingredient list, the test-kitchen notebook, the failed batches, and the oven settings. Both are generous. Only the second lets you reproduce and study the whole process. That gap is the gap between open weights and open source.

Training vs. inference

Training creates the weights. It is expensive and done once or rarely. Inference uses the weights to generate answers. It happens billions of times and is what most organisations actually pay for.

When you run a model yourself, the first question is almost always: will it fit in memory? Every engineer should be able to do this arithmetic in their head: parameters × bits ÷ 8 bytes.

memory_estimate.py
# Rough weight-only memory estimate (no KV cache, no activations)
def weight_memory_gb(params_billion, bits_per_param):
    return params_billion * 1e9 * bits_per_param / 8 / 1e9

for bits in [16, 8, 4]:
    print(f"21B model @ {bits:>2}-bit: {weight_memory_gb(21, bits):5.1f} GB")
21B model @ 16-bit:  42.0 GB
21B model @  8-bit:  21.0 GB
21B model @  4-bit:  10.5 GB
Fig 3 · Weight memory by precision (GB, weights only)
21B @ 16-bit21B @ 8-bit21B @ 4-bit 117B @ 16-bit117B @ 8-bit117B @ 4-bit 42 GB21 GB10.5 GB 234 GB117 GB58.5 GB
Raw BF16 weight sizes: 2 bytes per parameter at 16-bit, 1 at 8-bit, 0.5 at 4-bit. Real files add overhead, and gpt-oss ships in a compact quantized format.

This arithmetic explains why gpt-oss-20b, with 21 billion total parameters, is reported to need about 16 GB of memory. Its MoE design and compact format bring the footprint down to laptop range. Efficiency in the letter's sense is a memory and cost story as much as a quality story.

Inference is where AI becomes an operating cost. Memory decides which hardware can afford it.

Distillation: teaching with a big model's answers

Knowledge distillation trains a smaller "student" to imitate a larger "teacher". Hinton, Vinyals and Dean formalised it in 2015 (Distilling the Knowledge in a Neural Network). The key insight: a teacher's soft probabilities carry more information than its final answer. If a teacher says an image is 70% dog, 25% wolf and 5% cat, those ratios teach the student how dogs relate to wolves.

Fig 4 · The distillation pipeline
TEACHERlarge, strong SOFT TARGETSdog 70 · wolf 25 · cat 5 STUDENTsmall, cheap loss = α · KL(soft) + (1−α) · CE(labels)
Relatable scenario
A master chef teaches her palate, not just the menu. A junior cook who learns "this sauce is 70% acidic, 30% sweet, and here is why" learns faster than one who copies only the final plate. Distillation transfers that palate.

The distillation loss, in code

The classic loss combines two terms: match the teacher's softened distribution, and still learn the true labels. The temperature T softens both distributions. The T² factor keeps gradient sizes comparable.

distill_loss.py
import torch
import torch.nn.functional as F

def distillation_loss(student_logits, teacher_logits, labels, T=2.0, alpha=0.5):
    # 1. soft targets: match the teacher's softened distribution
    soft = F.kl_div(F.log_softmax(student_logits / T, dim=-1),
                    F.softmax(teacher_logits / T, dim=-1),
                    reduction="batchmean") * (T * T)
    # 2. hard targets: still learn the true labels
    hard = F.cross_entropy(student_logits, labels)
    return alpha * soft + (1 - alpha) * hard

torch.manual_seed(0)
loss = distillation_loss(torch.randn(4, 3), torch.randn(4, 3),
                         torch.tensor([0, 2, 1, 0]))
print("loss:", round(loss.item(), 4))
loss: (one scalar; exact value depends on the seed)

What the numbers say: DeepSeek-R1 and its distilled family

DeepSeek-R1 (January 2025) is the clearest recent example of distillation at scale. The authors released R1 plus six dense models distilled from it: 1.5B, 7B, 8B, 14B, 32B and 70B, built on Qwen and Llama bases. Their headline finding: distilling a large model's reasoning into a small model beat running reinforcement learning on that small model. For Qwen2.5-32B, RL alone reached about 47.0% on AIME 2024, while distillation from R1 reached 72.6%.

Fig 5 · AIME 2024 pass@1 (higher is better)
DeepSeek-R1 (teacher) OpenAI o1-1217 (closed) R1-Distill-Qwen-32B R1-Distill-Llama-70B OpenAI o1-mini (closed) R1-Distill-Qwen-7B R1-Distill-Llama-8B QwQ-32B-Preview 79.879.272.670.0 63.655.550.444.0
Reported AIME 2024 pass@1 scores from the DeepSeek-R1 paper and model cards. Bright green marks DeepSeek's models; the darker green marks the comparison models.
72.6%
AIME 2024, R1-Distill-Qwen-32B
94.3%
MATH-500, same 32B model
1691
Codeforces rating, same 32B model
ModelParamsAIME 2024MATH-500GPQA DiamondLiveCodeBench
R1-Distill-Qwen-7B7B55.5%92.8%49.1%37.6%
R1-Distill-Qwen-32B32B72.6%94.3%62.1%57.2%
R1-Distill-Llama-70B70B70.0%94.5%65.2%57.5%
Honest caveat: benchmark scores are not the whole story. Distillation transfers answers and reasoning patterns, not the teacher's full capability. Scores also depend on sampling settings, so check how each one was produced (pass@1, averaged, or majority vote).

Why this is in the letter

The letter calls distillation "a widely used technique for model improvement, evaluation, and validation". It also separates the technique from "unlawful efforts to extract value from closed models". These are different things. Distillation is a method. Whether a particular use is lawful depends on licences, terms of service and law. This guide covers the method only.

Mixture of Experts and quantization

A dense model uses every parameter for every token. A Mixture of Experts (MoE) model splits its feed-forward layers into many experts, and a small router picks only a few for each token. Total size can be large while the work per token stays small.

Fig 6 · Routing one token through 4 experts (2 active)
token router expert 1 expert 2 ✓ expert 3 expert 4 ✓ output 2 of 4 active Illustrative. gpt-oss uses 128 experts with 4 active per token.

This is why the gpt-oss numbers look odd at first glance. Total parameters describe memory. Active parameters describe work per token. Always report both.

Fig 7 · Total vs active parameters (billions)
gpt-oss-120b totalgpt-oss-120b active gpt-oss-20b totalgpt-oss-20b active 117B5.1B 21B3.6B
Total vs active parameters as reported by OpenAI for gpt-oss (August 2025). Active is about 4% of total for the 120B model.

Quantization: trading precision for reach

Quantization stores weights with fewer bits. Figure 3 showed the size effect. Quality loss depends on the method and the task, so measure after quantizing rather than assuming it is free.

117B
total parameters, gpt-oss-120b
5.1B
active per token, gpt-oss-120b
~16 GB
reported memory, gpt-oss-20b
128K
context window, both sizes

Safety, security and red teaming

Safety is about a model behaving as intended: refusing harmful requests, avoiding fabricated claims. Security is about attackers: stealing weights, extracting data, injecting malicious instructions. A model can be safe in conversation and still insecure once deployed.

Red teaming is structured adversarial testing: trying to make a model fail so the weaknesses get fixed before users find them. Benchmark contamination happens when test questions leak into training data and inflate scores.

The letter's core safety argument: open weights let many independent teams test the same model. Closed models can only be tested by their owner.

Relatable scenario
A vault whose blueprints are secret may be secure, or may have a flaw nobody outside can see. A vault with published blueprints invites many locksmiths to try to break it. Neither is automatically safe. The argument is about who gets to check the work.

The counterargument, stated fairly

The same openness that enables testing also enables misuse. Once weights are public, the developer cannot retract them, and anyone can fine-tune them, including for harm. OpenAI's gpt-oss release addressed this directly: it reported testing deliberately harmful fine-tuning and said the models did not reach its high-risk thresholds in the areas it assessed. That is a specific, measured claim. It does not mean all open weights are safe.

Fig 8 · The trade-off in one view
+ BENEFITS Many teams can test and audit Defenders get comparable tools Users can run models locally No single point of failure − RISKS Weights cannot be recalled Anyone can fine-tune them Safeguards can be removed Misuse is hard to trace
Summary of arguments made in the letter and in the release coverage. Both columns are real; the open question is the balance.
SAFETYModel behaves as intended.
SECURITYAttackers cannot abuse the system.
RED TEAMINGStructured attempts to break the model.
CONTAMINATIONTest answers leak into training data.

Sovereignty, lock-in and the application layer

Lock-in happens when switching providers is too costly: prompts, fine-tunes, data formats and workflows are tied to one API. Portability is the opposite. Sovereign AI generally means an organisation or country can run, inspect and control the AI it depends on, without relying on one external provider.

The application layer is where products are built on top of models: retrieval systems, agents, domain tools. The model layer is the models themselves. The letter's point is that competition at both layers matters, and open weights let many companies compete at the application layer without first training a frontier model.

Lock-in is a cost you pay later. Portability is a choice you keep now.

Four case studies

Case 1 · GPT-2 and the staged release (2019)

OpenAI initially withheld the full GPT-2 model, citing misuse concerns, and released it in stages over the following months while studying its effects. The debate was about how much to release and when, not whether openness has value. OpenAI later described gpt-oss (2025) as its first open-weight language models since GPT-2.

Key terms: staged release, misuse risk.

Case 2 · DeepSeek-R1 and its distilled family (January 2025)

DeepSeek released R1 with open weights and six distilled dense models. According to the authors, the distilled 32B model outperformed o1-mini on several reasoning benchmarks, and the distilled 14B model beat QwQ-32B-Preview by a large margin. The practical lesson: a well-distilled 7B to 32B model can run on hardware many developers already own.

Key terms: distillation, active parameters, benchmark evaluation.

Case 3 · gpt-oss (August 5, 2025)

OpenAI released gpt-oss-120b and gpt-oss-20b under Apache 2.0, its first open-weight language models since GPT-2. The 120B model activates 5.1B of 117B parameters per token and reportedly runs on a single 80 GB GPU. The 20B model has 21B total parameters, activates 3.6B, and reportedly needs about 16 GB of memory. OpenAI said the release was reviewed by external experts, and that the models did not reach high-risk thresholds in its preparedness evaluations, even after adversarial fine-tuning.

Key terms: open weight vs open source, MoE, Apache 2.0, preparedness evaluation.

Case 4 · The open-source ancestor

The letter opens with open-source software, and the analogy is historically grounded: open-source code now runs much of the internet's infrastructure. The lesson most often drawn is that inspectability and many contributors raise quality. The comparison is imperfect, though. Model weights are the result of training, not human-readable source code, which makes independent auditing harder in practice.

Key terms: open source, auditability, community review.

Try it yourself

A ten-minute checklist that turns this guide into practice:

Glossary

TermPlain-English meaning
Parameter / weightAn adjustable number inside a model. The learned knowledge lives here.
Open weightsTrained parameters anyone can download, inspect, modify and run. Licence terms vary.
Open source (OSI)Code and enough information to rebuild the work, under an approved licence.
Frontier modelThe most capable models available at a given time.
Closed modelAccessed only via API or app. Weights are not published.
InferenceRunning a trained model to produce outputs.
DistillationTraining a student to imitate a teacher's outputs or probabilities.
Fine-tuningFurther training a pretrained model on task-specific data.
QuantizationStoring weights at lower numerical precision to cut memory and cost.
Mixture of Experts (MoE)An architecture where a router activates only some expert sub-networks per token.
Active parametersParameters used for one token. In MoE models, this is smaller than the total.
Red teamingStructured attempts to make a model fail so weaknesses can be fixed.
Benchmark contaminationTest data leaking into training data, inflating scores.
Lock-inBeing unable to switch providers without high cost.
Sovereign AIRunning and controlling AI without depending on one external provider.
Application layerProducts built on top of models, such as search, agents and domain tools.

Sources

Figures were checked against the sources below at the time of writing. Benchmark scores change with evaluation settings, so re-check any number before you cite it in production work.

Send feedback

Found a wrong number, a confusing term, or a better example? Tell me. Every note goes straight to the author.

How useful was this guide?
0 / 1500