What Are Open-Weights Models? A Simple Explanation (And Why They're Eating the AI Market)

Introduction

If you've followed AI news over the past two years, you've seen the terms everywhere: DeepSeek releases open weights, GLM ships an open-weights update, MiMo drops a trillion parameters on Hugging Face under an MIT license. Meanwhile, models like GPT and Claude remain firmly closed. What's actually different about these two worlds -- and why does it matter for your costs, your privacy, and the products you can build?

This article explains open-weights models in plain language: what the "weights" are, what you get when they're released, how "open weights" differs from "open source," and why this trend is the main reason AI prices keep falling.

First: What Are "Weights," Anyway?

A large language model is, at its core, a gigantic mathematical function. It takes numbers in (representing your text) and produces numbers out (a prediction of the next token). The behavior of that function is defined by weights -- billions of adjustable numbers (roughly speaking, the strengths of connections between artificial neurons) that are tuned during training.

Think of it like this:

• The architecture is the blueprint -- the design of the network: how many layers, how attention works, how experts are wired together.
• The weights are the fully-built machine -- every learned knob and dial, the result of months of training on trillions of tokens.
• The training code is the recipe -- how the machine was built.

When a lab "releases open weights," it publishes the second item: the finished, trained machine. You can download it, inspect it, run it, and modify it. You usually do not get the recipe (exact training code and data), and you almost never get the ingredients list (the full training dataset).

What You Actually Get When Weights Are Open

Downloading an open-weights model typically gives you:

1. The model file(s) -- hundreds of gigabytes of numbers, usually in a format like safetensors, that inference software (vLLM, llama.cpp, TensorRT-LLM, etc.) can load and run.
2. A config file -- the architecture description so the software knows how to wire the machine together.
3. A tokenizer -- the dictionary that converts text to tokens and back.
4. A license file -- the legal terms that decide what you're allowed to do.
5. A model card -- documentation of intended use, limitations, and evaluation results.

From there, you can do four things closed models never allow:

• Run it yourself -- on your own servers, air-gapped from the internet, with no third party ever seeing your prompts.
• Fine-tune it -- continue training on your own data to specialize it (a legal firm's case law, a hospital's clinical language, a coding agent's private repos).
• Modify the behavior -- adjust system-level behavior in ways API providers may not permit.
• Ship it inside products -- embed the model in on-device apps or on-prem appliances without per-token fees.

"Open Weights" Is Not "Open Source" -- Here's the Difference

This trips up almost everyone. In software, "open source" has a well-established meaning: you get the source code, the right to modify it, and the right to redistribute derivative versions. The Open Source Initiative even maintains a formal definition.

Open-weights models borrow the spirit but not the full letter:

The critical variable is the license. Not all "open" models are equally open:

• MIT / Apache 2.0 -- maximally permissive. Commercial use, modification, redistribution: all fine. Models like MiMo-V2.6-Pro and many DeepSeek releases fall here.
• Community licenses (e.g., Llama-style) -- commercial use allowed but with riders: attribution requirements, naming rules, acceptable-use policies, or revenue thresholds above which terms change.
• Non-commercial -- research and personal use only. Many academic releases.

So when you see "open weights," always read one line further: which license? It's the difference between a model you can build a business on and one that's a legal liability.

Why Companies Give Away Models That Cost Millions to Train

Training a frontier model costs tens to hundreds of millions of dollars. Why would Xiaomi, DeepSeek, Zhipu, or Moonshot publish the result for anyone to download? Four strategic reasons:

1. Ecosystem gravity. If developers build tools, fine-tunes, and integrations around your model, you become the default platform. Android gave away the OS and won mobile; the play is the same.

2. Commoditize your complement. If your revenue comes from hardware, cloud services, or API infrastructure, making the model free increases demand for the thing you actually sell.

3. Talent and credibility. A top-ranked open release is the strongest recruiting and partnership signal an AI team can send.

4. Standard-setting. Open models establish benchmarks and interfaces that closed vendors must then compete against -- dragging the whole market's prices down, which paradoxically grows the total market.

The Economics: Why Open Weights Mean Cheaper AI

Here's the part that matters most to your invoice. When good open-weights models exist:

• Anyone can become a provider. Hosting a model is a competitive business, so providers compete on price instead of gatekeeping access.
• Retail prices track compute costs. Closed labs price against willingness-to-pay; open-model hosts price against GPU-hours. The gap between those two is enormous -- frequently 5x to 20x for equivalent capability.
• Aggregators pass the savings on. Marketplaces that buy inference on an open market where compute providers compete on price can offer flagship-class models at a fraction of list price, because they route to whoever serves it cheapest.

This is the core mechanism behind the price compression we've documented all year: every major open-weights release resets the price ceiling for a given capability level. A model scoring 46 on the Intelligence Index now costs well under $1 per million output tokens through competitive providers -- a price that would have bought you a mediocre model two years ago.

The Trade-Offs: What You Give Up

Open weights aren't free of downsides. A fair ledger looks like this:

Costs and complexity of self-hosting

• Big models need serious hardware; a 1T-parameter MoE needs a multi-node GPU cluster even though only a slice is active per token.
• You own uptime, scaling, security patching, and version upgrades.

Safety and guardrails

• Open weights can't be "unshipped." Fine-tuning away safety behaviors is possible, which is why licenses include acceptable-use clauses -- and why critics argue they're unenforceable.

Ecosystem polish

• Closed vendors bundle observability, evals, prompt management, and support. With open models you assemble that stack yourself -- or get it from your provider.

Benchmark caveats

• "Open" doesn't automatically mean "as good." Always check independent evaluations rather than the release blog post.

For most teams the sweet spot is a hybrid: use hosted open-weights models through an API (keeping the price advantage without the ops burden), and self-host only for workloads with strict data-sovereignty requirements.

How to Tell If an Open-Weights Model Is Right for Your Project

A quick checklist:

1. License check -- MIT/Apache? Community license with riders? Non-commercial? Match it to your use case and legal requirements.
2. Independent benchmarks -- look at third-party intelligence, coding, and agentic evals, not vendor charts.
3. Total cost math -- hosted open-weights price per token times your traffic, versus closed-model pricing, versus self-host GPU amortization.
4. Data sensitivity -- if prompts contain regulated data, open weights (self-hosted or on a provider with strong guarantees) may be the only compliant option.
5. Ecosystem fit -- does it support the tool-calling, structured output, and context length your stack assumes?

Conclusion

Open-weights models are the reason a developer in 2026 can call a trillion-parameter, million-token-context, omni-modal model for less than a dollar per million output tokens. They turned AI capability from a licensed service into a commodity -- imperfectly (it's "open weights," not full open source), but decisively.

The next time a headline announces a huge open release -- like today's MiMo-V2.6-Pro launch -- you'll know exactly what changed: the weights are on Hugging Face, the license decides what you can build, and the market price of that capability level just dropped again.

Ready to compare open-weights and closed models side by side, with real pricing? Browse the live catalog at Qubax models or dive into the API docs.

FAQ

Are open-weights models the same as free models?

No. The weights are free to download, but running them costs GPU time. Hosted providers charge per token (usually much less than closed models). "Free" applies to the artifact, not the compute.

Can I fine-tune an open-weights model on my own data?

Yes -- that's one of the biggest advantages. With permissive licenses like MIT or Apache 2.0, you can fine-tune on private data and deploy the derivative, including commercially. Always confirm the specific license first.

Which is better: open-weights or closed models?

Neither universally. Closed frontier models still often lead on the very hardest reasoning and tightly integrated agent features; open-weights models frequently match them on coding, summarization, and everyday tasks at 5x-20x lower cost. Benchmark your actual workload on both before committing.

Do open-weights models send my data anywhere?

The weights themselves are just files -- nothing phones home. If you self-host, your data never leaves your infrastructure. If you use a hosted API, your data handling depends on that provider's terms.

Where can I see open-weights model prices in one place?

The Qubax models page lists live, per-token pricing across open and closed models, including DeepSeek, GLM, Kimi, MiMo, GPT, and Claude families.