open weight

An open-weights model publishes its final trained parameters for anyone to download and run, while keeping the training data and the full training pipeline undisclosed — a genuinely different thing from open source, even though the two get conflated constantly. Meta's Llama 2 and 3, Mistral's models, Alibaba's Qwen, and Google's Gemma are all open-weights by this distinction: anyone can download the weights, run them locally, and fine-tune them, but none of these releases include the actual training corpus or the complete code needed to reproduce the model from scratch. The Open Source Initiative's own Open Source AI Definition, published in October 2024, draws this line formally, requiring full disclosure of training data and the complete training pipeline for a model to qualify as genuinely open source — a bar that EleutherAI's Pythia (2023) and the Allen Institute's OLMo (2024) clear by releasing their full training data and code, but that Llama, Mistral, and Gemma do not.

Model trained on a dataset
often undisclosed, proprietary, or only partially described
Only final weights + inference code released
the trained artifact, not the process that produced it
Can run, fine-tune, deploy locally
full practical control over the trained weights
Cannot reproduce or audit training data
the data that shaped the model stays invisible

For the overwhelming majority of real use cases, the gap between open-weights and true open source doesn't matter — but for a specific, important minority of cases, it's the entire point. Running inference, fine-tuning on a custom dataset, or building an application on top of a model requires only the weights, which is why open-weights models support the exact same local deployment, LoRA fine-tuning, and privacy-preserving on-premise use that fully open models do. What open-weights can never provide is training-data auditability: if a model exhibits a bias, memorizes copyrighted text, or behaves unexpectedly on some input, nobody outside the organization that trained it can trace that behavior back to a specific source in the training data, because that data was never disclosed in the first place — a limitation that matters enormously for copyright litigation, academic reproducibility, and bias research, and not at all for a team that just wants to deploy a chatbot.

Three Different Things Called "Open" per the OSI's Open Source AI Definition, October 2024 Open source Pythia, OLMo Weights: yes Training code: yes Training data: yes Fully reproducible from scratch Open weights Llama, Mistral, Gemma, Qwen Weights: yes Training code: no Training data: no Runnable, fine-tunable — not reproducible Closed / API-only most frontier hosted models Weights: no Training code: no Training data: no Access only through a hosted API Open weights sits deliberately in the middle — most of open source's practical freedom, none of its auditability.

The ecosystem that open-weights releases enable is large enough to be a genuine industry in its own right, not just a convenience for a few researchers. Hugging Face hosts well over 500,000 model variants derived from open-weights base models — fine-tunes for specific domains, merges combining several models' strengths, and quantized versions optimized to run on smaller hardware — an entire derivative ecosystem that a fully closed, API-only model cannot support, since there's no weights file for anyone outside the provider to build on top of in the first place.

Licensing terms, not just weight availability, determine what "open" actually permits, and the terms vary meaningfully across the models usually lumped together as open-weights. Mistral's and Falcon's Apache 2.0 license permits essentially unrestricted commercial use and redistribution; Meta's Llama Community License permits commercial use but adds specific conditions, including a restriction that applies once a company's products reach a stated monthly active user threshold; Google's Gemma ships under its own terms of service rather than a standard open-source license. Treating "open weights" as a single uniform category obscures real legal differences a team building a product needs to actually read before committing to a specific model.

The open-weights category exists because full open source and fully closed access aren't the only two options, and most of the practical value people actually want from "open" AI — local deployment, customization, no per-token API cost, freedom from a single provider's infrastructure — comes from having the weights at all, regardless of whether the data that produced them was ever disclosed; the cases where that distinction becomes load-bearing are exactly the cases, like auditing for bias or settling a copyright dispute, where somebody needs to trace a model's behavior back to a specific source it was never allowed to see.

Go deeper with CFSGPT

Get AI-powered deep-dives, save terms, and run advanced simulations — free account.

Create Free Account