Open vs. Closed Weights

What public weights mean, and when self-hosting actually pays off.

"Open-source model" borrows a term from software, but the meaning is far from the same. Open-source software gives you the full source code; an open model usually gives you the weights — a pile of trained numbers.

Signs you'll recognize:

• You assumed "open" means free, then priced self-hosting and found it more expensive than the API.
• You downloaded the weights, only to find the license forbids your kind of commercial use.
• Your boss says "use open source, it's safer for data" — but nobody priced the GPUs.

What's actually open

A model has three parts: training data, weights, and the training code and recipe.

"Open-source models," in most cases, release only the middle part — the weights. Training data is almost never released (copyright and trade secrets), and the full recipe usually isn't either.

The consequence: you can use it, but you can't reproduce it, and you can't tell what it learned. That's why the more accurate term in the industry is open-weight, not open source. The biases and gaps you'd find in the training-data article exist in open-weight models too — and they're harder to verify. When people debate what should count as "open source" for AI, the OSI definition is the reference point, and it's stricter than just publishing weights. osi-def

Closed models don't even give you the weights; you get an API. You don't know the architecture or parameter count, and if the vendor swaps models, you may not even notice.

What to check in the license

"Public" doesn't mean "use it however you like." Before downloading, confirm three things — yourself or with legal.

One, can you use it commercially? Some licenses allow research only; commercial use needs a separate grant.

Two, are there scale limits? Some licenses set user-count or revenue thresholds, beyond which you need another agreement. This one gets ignored most often — you discover it after the product grows, when switching models is already expensive.

Three, who owns the outputs and derivatives? Whether a fine-tuned model can be published, and whether it may stay closed, varies by license.

Licenses span a spectrum, from ones close to standard open-source terms to ones that are really "conditional free use." Don't trust the "fully open source" line on the vendor's landing page. Read the license text.

The real math of self-hosting

This is where the miscalculation happens. People equate "no API fee" with "free."

What you actually pay: GPUs (buy or rent; large models usually need several high-end cards), power and hosting, operations staff (deployment, monitoring, recovery, upgrades), and concurrency capacity (enough redundancy for however many people use it at once).

The catch is that most of these costs are fixed — they don't care whether you use the model or not. An API charges by usage; at 3 a.m., unused API costs nothing. Self-hosted GPUs sit there burning money even when idle.

So the conclusion is almost always: at low call volume, self-hosting's per-call cost is absurd; only once volume is high enough to spread the fixed costs does it possibly make sense. And "high enough" is usually far above what teams estimate.

There's a hidden line item too: the capability gap. Open-weight models still typically trail top closed ones, and you own the work of tracking new versions — with a closed API, you benefit from vendor upgrades automatically. ai-index

When self-hosting actually makes sense

Any one of these conditions makes self-hosting legitimate:

• Data absolutely cannot leave the building. Healthcare, finance, government, defense — compliance overrides every cost argument. This is the most legitimate and common reason.
• Volume large enough to amortize fixed costs. Run on the API for a while, then do the math with real usage: at the current rate, how long until self-hosting pays back? If you can't compute it, it's not time yet.
• Deep customization. Large-scale fine-tuning, model surgery, or deployment to an air-gapped environment — things closed APIs can't do.
• Eliminating vendor risk. You can't accept a model being de-listed, repriced, or rate-limited one day. Especially important for long-horizon B2B contracts.

If none apply, use the API. Drop the "open equals cheap" equation and you'll decide more clearly. What open source actually sells you is control: data stays in, the model won't disappear, you set the version — the same logic as choosing an access channel.

And there's a middle path worth knowing: managed open-weight models on cloud platforms. The weights are open, but the cloud handles deployment and operations and you pay per call. Model-selection freedom without running the hardware — for most teams, more realistic than a self-built cluster.