What “Open Weight” Actually Means
A plain explanation of the version of AI you can download, keep, and run without asking anyone.
What “Open Weight” Actually Means
A plain explanation of the version of AI you can download, keep, and run without asking anyone.
Baltimore, MD
“Open weight” gets thrown around as if everyone already agreed on the definition. Most people hear “open” and fill in “free” or “open source.” Neither guess is right.
Start with the weights.
A language model does one thing: it reads text and predicts what comes next. Feed it “the capital of France is” and it produces “Paris,” not because it looked anything up, but because that continuation scored highest.
The scoring is where the weights come in. Inside the model, words pass through layers of simple math units, each connected to thousands of others. Every connection has a number attached that sets how strongly a signal passes through, the way a dial on a mixing board sets how loud one input comes through in the final mix. Those numbers are the weights. A modern model has billions of them.
Nobody sets those dials by hand. Training works by brute repetition: show the model a chunk of text with the last word hidden, let it guess, measure how wrong the guess was, and nudge every weight a tiny amount in the direction that would have made the guess less wrong. Then do that again, trillions of times, across a large fraction of the written internet. After enough passes, the dials settle into positions where the model’s guesses come out right far more often than chance, across grammar, facts, tone, and reasoning patterns all at once.
That loop fits in twenty lines of Python. The model below has one weight instead of billions, and it learns one fact instead of a language: that outputs are three times the inputs. It is not told the three. It finds it. You can paste this into a free Google Colab notebook and run it with no setup.
# A model with one weight, learning by the same loop as the big ones:
# guess, measure the error, nudge the weight, repeat.
# The relationship to learn: output = 3 * input.
# The model doesn't know the 3. It has to find it.
inputs = [1, 2, 3, 4, 5]
targets = [3, 6, 9, 12, 15]
weight = 0.0 # the dial starts at zero
learning_rate = 0.002 # how big each nudge is
for step in range(51):
total_error = 0.0
nudge = 0.0
for x, target in zip(inputs, targets):
guess = weight * x # the model's prediction
error = guess - target # how wrong it was
total_error += error ** 2
nudge += error * x # which direction reduces the error
weight -= learning_rate * nudge # adjust the dial
if step % 10 == 0:
print(f"step {step:3d} weight = {weight:.4f} error = {total\_error:.2f}")
print(f"\nFinal weight: {weight:.4f}")
print(f"Prediction for input 10: {weight * 10:.2f}")
The output shows the dial turning:
step 0 weight = 0.3300 error = 495.00
step 10 weight = 2.1674 error = 48.13
step 20 weight = 2.7404 error = 4.68
step 30 weight = 2.9191 error = 0.45
step 40 weight = 2.9748 error = 0.04
step 50 weight = 2.9921 error = 0.00
Final weight: 2.9921
Prediction for input 10: 29.92
The weight starts at zero, overshoots nothing, and climbs toward three as the error collapses. It lands on 2.9921 rather than exactly 3, and that detail scales up: trained weights are approximations that got close enough for the error to stop mattering. A real language model runs this same loop with billions of dials adjusting at once and a far more complicated scoring of “wrong,” but nothing about the logic changes. Guess, measure, nudge, repeat. When a lab open-weights a model, the file you download is the final value of every one of those dials.
The finished model contains no stored text. There is no sentence about Paris saved anywhere in the file. The knowledge exists only as the collective positions of the dials. That is why the weights are the whole product: erase the training data, erase the code, and the model still works, but change the numbers and you have a different model.
When a company keeps a model closed, you never touch those numbers. You send your text to their servers, their copy of the weights does the work, and the answer comes back down the wire. That covers ChatGPT, Claude, Gemini, and nearly everything most people have used. You rent the intelligence one request at a time, and the weights never leave the company’s building.
An open weight model changes the ownership of that one thing. The company publishes the numbers. You download a file, often tens of gigabytes of it, and now the weights sit on your own drive. You run the model on your own machine, feed it whatever you like, and none of that conversation leaves your hardware.
Open weight is not open source
Open source, in the older sense, handed you the whole recipe: the code, and usually enough to rebuild the thing yourself from scratch. Open weight hands you the finished result without the recipe. You get the tuned numbers. You rarely get the training data, and you often don’t get the exact process that produced them.
You can run, study, and modify the weights you were given, but you cannot recreate them independently or verify what went into them. What the model learned from stays undisclosed, and any bias or gap in that training material ships with the file.
A stricter tier exists above this, where a lab also publishes the training data and the code that built the weights. Ai2’s OLMo goes that far. Most of the famous names stop at the weights.
Why a normal person would care
Ownership comes first. Every hosted model you use is a service, and services change underneath you. The company raises prices, retires the version you liked, rewrites the rules of what it will and won’t do, or shuts down. Anyone who used a hosted model for a year has watched at least one of these happen mid-project. A downloaded model does none of it. The file on your drive today behaves identically in five years. Nobody can push an update to it, meter it, or switch it off. You stop being a subscriber and start holding an asset.
That permanence changes how you can operate. With a hosted model, the version you built your habits or your tools around disappears on the vendor’s schedule, and the replacement behaves differently in ways you discover the hard way. With a downloaded one, the version you tested is the version you run, for as long as you choose. If a newer model comes out, you evaluate it on your own timeline and switch when it earns the switch, keeping the old file as a fallback.
Cost follows the same logic. Renting bills you per request, forever, at a rate the vendor sets and can change. Download one and the meter stops after the initial transfer, give or take the electricity. A million uses cost the same as ten, which turns the model from a recurring expense into a one-time acquisition.
You can also change the thing itself. Small teams take an open weight model and retrain a slice of it on their own material, a law firm on its own contracts, a clinic on its own notes, until it speaks their dialect. A rented model offers you settings. An owned one offers you the dials.
Privacy rides along with all of this rather than driving it. A model running on your own machine can read your tax documents and your drafts without any of it reaching a company’s server logs, not because anyone promised, but because nothing leaves the machine.
The catches
You need hardware. The big capable models want a serious graphics card or a recent Mac with a lot of memory, and the largest ones still won’t fit on anything you own. The small ones run on a laptop and give up some quality in exchange.
The license matters, and people skim right past it. “Open weight” tells you the numbers got published. It says nothing about what you are allowed to do with them. Some models carry genuinely permissive terms, Apache 2.0 or MIT, that let you do nearly anything, including selling what you build. Others carry custom licenses with restrictions. Meta’s Llama, for one, has had terms that limited use inside the EU. Having the file on your drive settles nothing about what the license lets you do with it.
The safety work becomes yours, too. A rented model arrives with guardrails the company maintains. A downloaded one does whatever its weights do, and if you strip the guardrails off, nobody stops you. The same freedom that lets a clinic tune a model on private records lets someone else tune one for scams.
Who actually ships these
The list of companies publishing open weights got long over the past two years, and many of the names on it are unfamiliar to most people.
Meta’s Llama models pushed the category into the mainstream. Google ships Gemma, Mistral ships from France, Microsoft ships its small Phi models, NVIDIA ships Nemotron, and OpenAI, after years of keeping everything locked, released open models it calls gpt-oss.
Much of the current frontier comes out of Chinese labs. DeepSeek, Qwen from Alibaba, Kimi from Moonshot, and GLM from Z.ai ship open weight models that score within a few points of the best closed Western models on independent coding and intelligence benchmarks, at a fraction of the per-token price. Artificial Analysis tracks the leaderboards, and as of mid-2026 the UK’s AI Security Institute puts the capability gap between open and closed frontier models at four to seven months, down from six to ten a year earlier. The production shift followed: Chinese open weight models now carry a large share of the traffic on OpenRouter, the routing service many developers use to reach models, which means real workloads, not benchmarks.
The small ones are the ones you can actually use
The headlines cover the giants, models with hundreds of billions of parameters that need a rack of server hardware to run. For a person with a laptop, the small ones matter more.
Model size gets measured in parameters, which is just a count of those weights. The frontier models run into the hundreds of billions or beyond. But labs also ship deliberately compact versions, in the range of one to thirty billion parameters, built to fit on hardware people already own. Gemma comes in sizes down to one billion. Phi was designed small from the start. Qwen ships a whole ladder of sizes under the same name. A trick called quantization shrinks them further, storing each weight in less precise numbers, and the quality loss is smaller than you’d expect while the file drops to a half or a quarter of its size.
A model in the seven-to-fourteen billion range, quantized, runs comfortably on a MacBook with 16 gigabytes of memory or a PC with a mid-range gaming card. That hardware sat under a lot of desks before anyone cared about AI.
Getting one running stopped requiring any real skill about two years ago. Tools like Ollama and LM Studio wrap the whole process. You install the app, pick a model from a list, and it downloads and runs. LM Studio gives you a chat window that looks like any AI website, except the site is your own machine. Turn the wifi off and the model keeps answering.
What changes in practice, once it’s local:
The meter disappears. Every API call to a hosted model bills by the token, a token being roughly three-quarters of a word, in and out. Costs stay invisible at small volume and then arrive all at once when a script loops overnight or a side tool gets popular. A local model processes ten documents or ten thousand for the same price, which is the electricity to keep the fan spinning.
So do the limits that come with sharing someone else’s servers. Hosted models throttle how many requests you can send per minute, queue you during peak hours, and go down when the provider goes down. A local model has exactly one user. It answers as fast as your hardware allows, every time, with no quota to hit and no status page to check.
Offline becomes real. The model works on a plane, in a dead zone, during an outage, behind a corporate firewall that blocks AI sites. Everything it needs is in the file on your drive.
Your data stays on your machine as a side effect of the architecture. For medical notes, legal drafts, or a journal, that matters, and it requires no trust in anyone’s policy because nothing gets transmitted in the first place.
And the small ones are good enough for most of what people actually do. Summarizing documents, drafting and rewriting text, answering questions about a file, basic coding help, all of it sits well within a modern 8-billion-parameter model’s reach. The frontier giants pull ahead on hard reasoning and deep domain expertise, which most everyday tasks don’t require.
A small local model works like a sharp junior assistant. It handles the routine load well and fumbles complex multi-step reasoning that a frontier model handles cleanly. The pattern that works is using the local model for the everyday volume and the private material, and saving the paid calls for the problems that earn them.
The practical upshot
When a model gets called open, that usually means one specific thing: you can download the weights and run them yourself. The copy on your drive is yours to keep, nobody can update it, meter it, or switch it off, and the running cost drops to electricity. The small versions run on hardware you likely already own, through tools that ask nothing more of you than installing an app, with your data staying local as a byproduct. What the word does not promise is the recipe, or the right to do whatever you want with what you downloaded. Both of those depend on the license, so read it before you build anything on top.
By Joshua McDonald on July 21, 2026.
Exported from Medium on August 26, 2026.
Reader discussion