This page compares the two ways to use a language model: as a closed service, or as open weights you run yourself or through a host of your choice. Neither is better in general. The right choice depends on how capable the model must be, what data it handles, and how much infrastructure you want to run.
What closed and open mean
A closed model is available only as a service. The provider keeps the parameters secret and runs the model on its own servers. You reach it through an app or an API and pay per use. OpenAI’s GPT models, Anthropic’s Claude, and Google’s Gemini are closed.
An open-weight model publishes its trained parameters for download. Anyone can run it on their own hardware, change it through fine-tuning, and build products on it within the terms of its license. Meta’s Llama, Google’s Gemma, Mistral’s open models, DeepSeek, and Alibaba’s Qwen are examples.
“Open weights” is not the same as open source. Open-source software publishes everything needed to rebuild it. Most open-weight models publish only the finished parameters, not the training data or the full training code, so nobody can reproduce or fully inspect how they were made. The Open Source Initiative published a definition of open-source AI in 2024 that requires much more openness than most models offer. A few research projects, such as the OLMo models from the Allen Institute for AI, release data and code as well.
Licenses differ
Open weights come with a license, and the licenses vary:
- Permissive licenses such as Apache 2.0 and MIT allow almost any use, including commercial products. Many Mistral, Qwen, and DeepSeek models use them.
- Custom community licenses allow commercial use with conditions. Meta’s Llama license, for example, requires a separate agreement for companies with very large user numbers and includes an acceptable use policy.
- Research-only licenses forbid commercial use.
Read the license of the specific model version before building a product on it. The terms can change between versions of the same family.
How they compare
| Aspect | Closed model | Open-weight model |
|---|---|---|
| Capability | Usually the most capable models | Often a few months behind the frontier |
| Getting started | An API key and a few lines of code | Hardware or a hosting provider, plus setup |
| Cost structure | Pay per token | Pay for hardware and operations, or per token at a host |
| Data | Sent to the provider | Can stay entirely on your servers |
| Customization | Prompting, limited fine-tuning offered by the provider | Full fine-tuning and modification |
| Stability | The provider can change or retire a model | A downloaded version stays the same forever |
| Operations | The provider handles scaling and uptime | You handle scaling and uptime, unless you use a host |
| Offline use | Not possible | Possible |
Capability
The most capable models have been closed so far, and they lead on the hardest tasks: complex reasoning, long agentic work, and difficult code. Open-weight models have closed much of the gap, and for many everyday tasks, such as summarizing, classifying, extracting, and drafting, a good open model is enough.
Cost
A closed model costs nothing until you use it, and then costs per token. An open model on your own hardware has a fixed cost regardless of use. At low or irregular volume, an API is almost always cheaper. At high, steady volume, or when a small open model is enough, running it yourself can cost less. Inference providers that host open models sit in between: per-token pricing, often lower than closed models of similar quality.
Privacy and control
With your own deployment, prompts and documents never leave your infrastructure. That matters for health data, legal documents, trade secrets, and in regulated industries. It also protects against a provider changing a model’s behavior, raising prices, or retiring a version your product depends on.
Safety
Open weights are a safety debate. Safeguards trained into an open model can be removed by fine-tuning, and a released model cannot be recalled. Supporters argue that open models allow independent research, auditing, and competition, and that concentrating the technology in a few companies is a risk of its own. Many labs now release open models only after testing them for dangerous capabilities.
Running a model yourself
Small open models run on a laptop. Tools such as Ollama, LM Studio, and llama.cpp download a model and run it locally with one command:
ollama run gemma3The hardware you need depends on the model’s size. A model’s parameters must fit into the memory of the GPU, or the computer’s memory on machines that share it. Quantization stores each parameter in fewer bits and cuts the memory need roughly in half or more, with a small loss of quality. As a rough guide, a model with about 8 billion parameters runs on a laptop with 16 GB of memory, while the largest open models need several data center GPUs. Servers that handle many users run engines such as vLLM, which are built for throughput.
When to choose which
Choose a closed model when you need the strongest capability, when you want to start quickly, when usage is low or unpredictable, or when you do not want to operate infrastructure.
Choose an open-weight model when data must stay in your control, when you need to work offline or in an isolated network, when you want to fine-tune deeply, when you need a version that never changes, or when high, steady volume makes your own hardware cheaper.
Many teams use both: a closed frontier model for the hardest tasks and an open model for high-volume or sensitive ones. An application that calls models through a common interface can switch between them as models and prices change.
Check your understanding
Question 1 of 5
0 of 5 checked