Open-weight and closed models | Constellation Gate AI

The short answer

An open-weight model is one whose trained parameters are published for anyone to download; a closed model can only be reached through the vendor’s service. That single difference decides where the model runs, whose hardware it runs on, whose terms govern it, and whether anyone can take it away from you. It does not, on its own, decide which model is better at your task.

The word “open” is doing more work in that sentence than it looks.

Fig. 1Model licences and vendor terms, Aug 2026

What the open and closed split actually settles, and the one question it leaves open.

What “open” means here

Published weights and open source are not the same claim, and the bodies that define the terms are explicit about it.

The Open Source Initiative’s definition of open source AI asks for four freedoms, to use the system for any purpose without asking permission, to study how it works, to modify it, and to share it. To make those freedoms real it requires three things: the parameters, the code used to train and run the system, and data information detailed enough that a skilled person could build a substantially equivalent system. On that standard, a weights-only release is not open source, and the OSI says so directly: open source models and open source weights must include the data information and code used to derive those parameters.

Almost no widely used release meets that bar. Weights get published; training data usually does not. The EU’s AI Act assumes as much in its own text, noting that releasing a model under a free and open-source licence “does not necessarily reveal substantial information on the data set used for the training”.

So openness is a spectrum. The US Commerce Department’s NTIA makes the same point in its report on open model weights: weights, code, training data, and documentation are separate release decisions, each available through different channels with different restrictions. “Open weights” is the honest description of what most of these releases are, and it is the useful one, because the weights are the part that changes what you can do.

What the licence restricts

Downloadable does not mean unrestricted, and the terms vary more than the marketing does.

	What it permits	What it asks of you
MIT	Anything, commercially, with no user threshold or field-of-use limit. DeepSeek ships its current V4 weights under it	Keep the copyright and permission notice
Apache 2.0	The same breadth, plus an explicit patent grant. Qwen’s and Mistral’s smaller current releases use it, and Gemma 4 moved to it from Google’s older custom terms	Pass on the licence, mark modified files, keep notices
Llama Community Licence	Commercial use by default, with a threshold: past 700 million monthly active users you must request a licence from Meta, granted at its discretion	Display “Built with Llama”, prefix derived model names with “Llama”, ship the notice file, follow Meta’s acceptable use policy
Vendor-specific terms	Varies, sometimes gated behind an access request	Read it. Licence can differ between sizes in one family, and the large model is often the restricted one

Two things follow. The first is that the licence is per model, not per vendor: within a single family the small models can be Apache 2.0 while the flagship is under custom terms. Mistral is unusual in labelling each model in its own catalogue “Open” or “Premier”, which is the transparency the rest of the field could copy.

The second is that acceptable-use policies travel with some of these licences by reference. That is a compliance surface, not a formality, and it is easy to inherit without noticing.

Three ways to run one

Downloading weights is not the only way to use an open model, and it is often the worst one.

Your hardwareYou hold the weights and the requests never leave. vLLM and llama.cpp are the two programs most people use to run a model themselves, the second aimed at doing it “with minimal setup and state-of-the-art performance on a wide range of hardware”, including ordinary computers.

HostedSomebody else runs the same weights and sells you tokens. AWS Bedrock names DeepSeek, Mistral, Meta and Qwen among its providers, and services like Together, Groq and Hugging Face’s inference providers do the same. Open weights, closed operations.

A gatewayOpen and closed models arrive through one interface, so the choice per task stops being an integration decision. What that layer is, and what else it can do from that position, is its own topic.

Only the first option changes where your data goes. The other two give you the licence freedoms and the model choice without the operations, which for most teams is the point.

What self-hosting requires

The weights are free. The rest is not.

Start with memory, because it is the constraint people meet first. The whole model has to fit in fast memory, and the number is large: Falcon-40B’s own model card asks for 85 to 100GB of memory to run it, and that is a model several generations old and modest by current standards. The standard answer is quantization, which stores the model in a coarser form so it takes less memory while, in Hugging Face’s own framing, trying to preserve as much accuracy as possible. Trying is the operative word. It is a trade, and how much you give up depends on the method and how far you push it.

Then hardware. Serving stacks publish floors: vLLM asks for compute capability 7.5 or higher on NVIDIA and lists supported AMD and Apple paths, Ollama supports NVIDIA GPUs at compute capability 5.0 and above with a recent driver. Meeting the floor gets you a running model, not a fast one.

Then everything a provider was quietly doing. Capacity when traffic spikes. Upgrades. Latency under concurrent load. Whatever screening sat between the model and your users. None of it arrives with the download, and all of it is now your name on the deployment.

Self-host when the requirement is that data does not leave, or when volume is high enough and steady enough that owning the hardware beats renting tokens. Self-hosting to save money on bursty, modest traffic rarely survives contact with the bill.

What each side is better at

	Open weights	Closed models
Where the data goes	Wherever you run it, including nowhere	The provider, under its terms
Who can retire it	Nobody. Weights you hold keep working	The vendor. Retired models stop answering, on a published schedule
Cost shape	Hardware and operations, mostly fixed	Per token, and it scales with use in both directions
Customisation	Fine-tuning, quantizing, and modification are yours to do	What the provider exposes
Frontier capability	Strong and improving, and usually behind on the newest jobs	Where the newest capabilities land first
What comes bundled	Nothing. Screening, limits and records are yours to build	An operations layer you inherit for as long as you stay with one vendor

The split is not tribal either. OpenAI publishes weights for at least one model while its main family stays closed, and Google’s newest open generation moved to a plainer licence than its last one. Treating open and closed as opposing camps mostly gets in the way of picking per task, which is what the decision is.

Common questions

Is an open-weight model the same as open source?+

No, and the difference is defined rather than a matter of opinion. The Open Source Initiative requires the training code and detailed data information alongside the parameters. Nearly all “open” model releases publish weights only, which makes open weights the accurate term.

Can I use these commercially?+

Usually, and check anyway. MIT and Apache 2.0 releases put no commercial restriction on you. Meta’s Llama licence permits commercial use but requires a separate licence past 700 million monthly active users, and carries naming and attribution conditions that apply to anything you build on it.

Is anyone running open models in production?+

Enough to be visible in marketplace traffic. Over a trailing month of OpenRouter’s published rankings, models with a public weights repository accounted for roughly 70% of tokens processed. That measures one marketplace, not the industry, and it excludes traffic going directly to the big providers’ own APIs, which is where most closed-model volume sits. It does show that open weights are not a hobbyist story.

Do I need a GPU?+

For a large model at speed, yes. Small quantized models run on a laptop, and llama.cpp exists largely to make that work. The gap between “it runs” and “it serves ten people at once” is where hardware budgets go.

What happens to my open model when the vendor moves on?+

Nothing. That is the strongest practical argument for holding weights: a closed model that reaches its retirement date stops answering, while a downloaded model keeps working for as long as you keep running it. What you lose is the improvements.

Should we run one model or several?+

Several, if the work differs, and it usually does. The cost of a mixed setup is the integration rather than the models, which is why teams tend to reach for one interface across both kinds rather than wiring each provider separately.

Keep learning

Data and privacy What happens to the data you send a model Cost What a request to an AI model costs Models Why models get things wrong