What an open-weights AI model is, and what you can and can't do with one

An open-weights AI model is one you can download in full and run on your own computer or server. When you use ChatGPT, your question travels to OpenAI's servers, the model works out an answer there, and you only get the text back. With an open-weights model such as Meta's Llama, Alibaba's Qwen, OpenAI's gpt-oss or Mistral Large 4, the file that does the work sits on your drive and the answer is computed on your machine.

That gives you control over where your data goes and lets you adapt the model to your needs. The trade-offs: you need hardware with enough memory, you don't get to see what text the model was trained on, and you have to follow a license that each company writes its own way.

What weights are and where they come from

Under the hood, a language model is a huge chain of math operations. It takes text that has been turned into numbers and predicts which chunk is most likely to come next, as we explain in how ChatGPT works. Each of those operations multiplies by a set of stored values. Those values are the weights, also called parameters, and a large model has billions of them.

Nobody writes them by hand. At the start of training they're close to random, and the model gets most predictions wrong. It then reads an enormous amount of text and tries to guess each next word. Every time it misses, a mathematical procedure nudges all the weights slightly in the direction that would have shrunk the error. After that guessing game has been repeated across trillions of words, on thousands of chips over weeks, the weights end up encoding what the model learned, from grammar to facts about the world. Mistral, for example, trained its Large 4 model on 3,800 NVIDIA chips.

All that work ends up in a set of files. Releasing the weights means handing over those files, the expensive, hard-to-reproduce part. What doesn't come with them is what it took to make them: the training text, the code that ran the process and the decisions made along the way.

Open weights vs. open source vs. closed models

People mix up these three labels all the time, but they mean different things:

• Closed model. You can only use it through the company's website, app or API, and the weights never leave its servers. That's how ChatGPT, Claude and Gemini work.
• Open-weights model. You download the weights and run them wherever you like, under the terms of its license. The training data and the full code needed to reproduce it usually aren't released.
• Open-source AI. The Open Source Initiative (OSI), the group that decides which software licenses count as open source, published its definition for AI in 2024. It requires that anyone can use the system for any purpose without asking permission, study it, modify it and share it. Beyond the weights, it calls for the complete code used to train the model and to run it, plus a description of the training data detailed enough for a skilled person to build a substantially equivalent system.

The OSI doesn't require releasing the data itself, but it does require saying what was used and where to get the public parts. And a license that demands permission above a certain size, or rules out a type of business, doesn't grant the freedom to use the model for any purpose. That's why many models marketed as open are more accurately described as open weights. At the other end of the spectrum is OLMo, from the research institute Ai2, which releases its weights, code and full training data under the Apache 2.0 license.

What you can do with open weights

Run it on your own hardware. If the model fits on your computer, it works offline with no subscription, and the text you give it stays on your machine while it generates an answer. Privacy also depends on what you connect to the model. Give it a search tool or access to another service and that data does leave, as we cover in our local vs. cloud AI guide.

Adapt it to your task. With the weights in hand, you can keep training the model on your own examples, known as fine-tuning, so it answers in the format, tone or vocabulary you need. Our fine-tuning guide explains when that's worth it and when feeding it documents is enough. With a closed model, you can only do this if the company offers it, on its terms.

Decide where it lives and for how long. Your downloaded copy stays the same even if the company changes the model or pulls it from its service, and a business or government agency can install it on its own servers without sending documents to anyone.

What you can't do

See what it was trained on. The weights don't tell you which texts the model read, whether they included copyrighted work or personal data, or why it answers the way it does. They're billions of numbers, not a manual you can read.

Ignore the license. Open doesn't mean unconditional. Llama 4's license requires companies with more than 700 million monthly users to ask Meta for permission, and downloading the weights means giving your name, date of birth and organization on its Hugging Face page. Mistral Large 4's license allows free commercial use but requires a separate contract from anyone reselling it as a hosted service. Others, such as gpt-oss and Qwen3.8-27B, use Apache 2.0, a standard software license that permits almost any use.

Expect it to improve on its own. A downloaded model doesn't learn from how you use it and doesn't update itself. When the company releases a better version, you have to download it and swap out the old one.

What computer you need

Memory matters most. Most of a model's math runs on the graphics card, which can do thousands of multiplications at once. To run at a usable speed, the whole model has to fit in the card's memory, or, on computers like Apple silicon Macs, in the unified memory that the processor and graphics share, with some room left over for the text it's working on. If it doesn't fit, programs like llama.cpp can spill it into regular system memory, but it runs much more slowly.

How much space a model takes depends on its parameter count and how many bits each parameter is stored in. A bit is the smallest unit of computer data, and eight of them make a byte. The more bits each number gets, the more precise it is and the more space it takes. Take Qwen3.8-27B, which has 27 billion parameters. Its file is 53.8GB stored at 16 bits (two bytes per parameter), 28.6GB at 8 bits and 19GB in the roughly 4-bit version most people use on personal computers. By our math, that last one fits on a 24GB graphics card but not on a 16GB one. Compressing to fewer bits costs some accuracy, and how much varies by model.

With that rule in mind, here's a rough size guide as of October 2026:

• Small models, up to about 30 billion parameters. OpenAI says gpt-oss-20b runs within 16GB of memory, so a laptop or a PC with a good graphics card will do.
• Mid-size models, roughly 100 billion to 200 billion parameters. OpenAI says gpt-oss-120b fits on a single 80GB data center GPU, and NVIDIA says its compact DGX Spark, with 128GB of unified memory, supports models of up to 200 billion parameters.
• Giant models, hundreds of billions of parameters or more. Mistral Large 4 takes up 1.06TB in its full version and, as we reported when it was released, even heavily compressed it needs a Mac with 512GB of memory.

If you don't have that kind of hardware, many open-weights models are also available through APIs from companies that run them for you. You give up the privacy advantage, but you keep the option to switch providers or move the model onto your own servers later. Before you download, check which file format your app expects, which we explain in GGUF vs. safetensors.