# Open weight models in 2026: licenses, families, hosting

URL: https://infro.io/blog/open-weight-models-2026
Author: INFRO Editorial (https://infro.io/blog/editorial)
Publisher: INFRO
Published: 2026-10-19
Last modified: 2026-10-19
Last reviewed: 2026-10-19 (next review due 2026-11-18)
Topic: Evaluation and models
Format: Guide

> Open weight models are models whose trained parameters you can download and run yourself, under a license that sets what you may do with them. Open weights is not the same as open source: the training data and code usually stay private, and several families attach conditions such as attribution, revenue thresholds or use restrictions. As of 19 October 2026, gpt-oss, Qwen3.8-27B, Gemma 4 and Mistral Small 4 and Large 3 ship under Apache 2.0 and DeepSeek V4.1 Flash under MIT, while Llama, Kimi K3, GLM-5.3 and MiniMax M3 use their own licenses.

Key takeaways:
- Open weights means you can download and run the parameters. It does not mean you get the training data or training code, which the Open Source AI Definition requires.
- The license is part of the model. Apache 2.0 and MIT are short and permissive; Llama, Kimi K3, GLM-5.3 and MiniMax M3 add attribution, revenue thresholds, notices or prohibited uses.
- Size decides where a model can run: gpt-oss-20b fits in 16 GB, gpt-oss-120b on one 80 GB GPU, while trillion-parameter models such as Kimi K3 need a multi-GPU node or a host.
- The same weights on two hosts can differ in context window, precision and status. Groq lists Qwen3.8-27B with a 131,072-token window, half of the model card's native 262,144.
- Choose open weights for control, portability or data path, not by default; evaluate each model on each host you would actually use.

Open weight models are models whose trained parameters are published for download, so you can run them on your own hardware or pick any host that serves them, under a license that says what you may do with them. That makes them portable in a way a closed API model is not. It does not make them open source, and it does not make every license permissive.

This guide covers what "open weights" gives you, the licenses attached to the main families as of 19 October 2026, a table of what each family publishes and where it can run, and when open weights are the right choice.

## Open weights vs open source: what you actually get

An open weight release gives you the parameters: the files a serving engine loads to run the model. Usually it also gives you a model card, a chat template and inference examples. It rarely gives you the training data or the code that produced the weights.

The Open Source Initiative's Open Source AI Definition 1.0 sets a higher bar. It requires the "preferred form for modification" in three parts: detailed information about the training data, the complete source code used to train and run the system, and the model parameters. It also requires four freedoms: to use the system for any purpose without asking permission, to study it, to modify it, and to share it[1].

Most of the models in this guide meet the parameters requirement and, under a permissive license, the freedoms. Few publish training data information in the depth the definition asks for. "Open weights" is the accurate term, and it is the one this guide uses.

What open weights change in practice:

- **You choose the host.** The lab that trained the model and the company that runs it can be different parties, so the data path is a hosting decision, not a model decision. This is the core of [running Chinese open-weight models in production](https://infro.io/blog/chinese-open-weight-models-guide-2026).
- **You control versions.** A checkpoint you downloaded does not change underneath you. A hosted API can.
- **You can fine-tune.** The weights are the starting point for your own variant, subject to the license.
- **You take on what a closed API hides.** Serving, capacity, upgrades and license compliance become yours, or your host's.

## The licenses, from permissive to conditional

Read the license attached to the exact model you deploy. It can differ between families, and between models inside one family.

### Apache 2.0 and MIT

The simplest case. gpt-oss-120b and gpt-oss-20b are Apache 2.0[2][3]. So are Qwen3.8-27B[4], Gemma 4 31B[5], Mistral Small 4[6] and Mistral Large 3[7]. DeepSeek V4.1 Flash uses the MIT License, which its card says covers both the repository and the model weights[8]. These allow commercial use, modification and redistribution, with notice requirements and no warranty.

### Community licenses with thresholds

Meta's Llama models use custom community licenses. The Llama 3.3 Community License requires a separate license from Meta if your products exceed 700 million monthly active users, a visible "Built with Llama" notice, model names beginning with "Llama" for models trained on Llama outputs that you distribute, and compliance with an acceptable use policy[9]. Llama 4 Scout carries the Llama 4 Community License with the same 700 million user threshold[10].

### MIT-style licenses with commercial conditions

Several 2026 releases start from MIT's permission text and add conditions:

- **Kimi K3** (Moonshot AI): a company offering third parties API access to the model's inference or fine-tuning needs a separate agreement once its revenue passes $20 million over any 12 months; products above 100 million monthly active users or $20 million in monthly revenue must display "Kimi K3" in their interface. Internal use that exposes nothing to third parties is exempt[11].
- **GLM-5.3** (Z.ai): a model-as-a-service business with more than $10 billion in revenue over 12 months must pass Z.ai's security review before commercial use; embedding the model in product features or relaying requests to models hosted by others does not count[12].

### Licenses with notices and prohibited uses

The MiniMax Community License for MiniMax M3 is the most restrictive of those read for this guide. Commercial use requires a visible "Built with MiniMax M3" notice, a one-time notice to MiniMax at or below $20 million in yearly revenue and prior written authorization above it. It also prohibits specific uses, including any military purpose[13].

Qwen's largest model, Qwen3.8-2.4T-A95B, is listed under a license named "qwen3.8-max" rather than Apache 2.0[14]. The smaller Qwen3.8 models and the largest one are not under the same terms, which is exactly why the license check belongs to the model, not the family.

> **Warning: Not legal advice**
> These summaries are what each license file says, read on 19 October 2026. Licenses change between versions. Have counsel read the license of the exact checkpoint before you ship a product on it.

## The main open weight families as of October 2026

The table lists one or two current models per family whose model card was opened for this guide. Sizes are as each card states them; "active" applies to mixture-of-experts models, which load all parameters but use a fraction per token.

| Family | Model | License | Size | Context | Where it can run |
| --- | --- | --- | --- | --- | --- |
| gpt-oss (OpenAI) | gpt-oss-20b | Apache 2.0 | 21B total, 3.6B active | — | Within 16 GB of memory; vLLM, Ollama, Transformers[3] |
| gpt-oss (OpenAI) | gpt-oss-120b | Apache 2.0 | 117B total, 5.1B active | — | One 80 GB GPU such as H100 or MI300X[2] |
| Llama (Meta) | Llama 3.3 70B Instruct | Llama 3.3 Community | 70B dense | 128K | More than one 80 GB GPU at 16-bit[9]; Groq serves it[15] |
| Llama (Meta) | Llama 4 Scout | Llama 4 Community | 109B total, 17B active | 10M | One H100 with int4 quantization[10] |
| Gemma (Google) | Gemma 4 31B | Apache 2.0 | 31B dense | 256K | vLLM, SGLang; quantized builds for llama.cpp, Ollama[5] |
| Qwen (Alibaba) | Qwen3.8-27B | Apache 2.0 | 27B dense, with vision | 262,144 native | SGLang, vLLM[4] |
| Qwen (Alibaba) | Qwen3.8-2.4T-A95B | qwen3.8-max | 2.4T total, 95B active | 262,144 native | Multi-node cluster or a host[14] |
| DeepSeek | DeepSeek V4.1 Flash | MIT | 763B listed, FP8 weights | Up to 1M | vLLM, SGLang[8] |
| Mistral | Mistral Small 4 | Apache 2.0 | 119B total, 6.5B active | 256K | vLLM[6] |
| Mistral | Mistral Large 3 | Apache 2.0 | 675B total | 256K | One 8×H200 or B200 node at FP8[7] |
| Kimi (Moonshot AI) | Kimi K3 | Kimi K3 License | 2.8T total, 104B active | 1,048,576 | vLLM, SGLang on a multi-GPU cluster[16] |
| GLM (Z.ai) | GLM-5.3 | GLM-5.3 license | 753B listed | Not stated on card | SGLang, vLLM, KTransformers[17] |
| MiniMax | MiniMax M3 | MiniMax Community | ~428B total, ~23B active | 1M | SGLang, vLLM[18] |

Table: Facts as stated on each model card on 19 October 2026. A dash means the card opened for this guide did not state it.

Three notes on reading it:

- **Llama's newest checkpoints are older than the rest.** The most recently updated language models on Meta's Hugging Face organization are the Llama 4 releases, last updated in May 2025[19]. Every other family in the table shipped in 2026.
- **Gemma 4 spans the range.** Besides the 31B dense model, the collection holds a 26B mixture-of-experts model with about 4B active parameters and E2B and E4B models aimed at edge devices[20].
- **Precision is part of the release.** gpt-oss ships MXFP4 weights for its experts, which is why the 120B model fits one 80 GB GPU[2]; Kimi K3 was trained with MXFP4 weights and MXFP8 activations[16]; DeepSeek V4.1 Flash publishes FP8 weights[8]. A host that serves a different precision is serving a different numerical model.

## Self-host or use a hosted provider?

The weights are the same either way. What changes is who runs them.

|  | Self-hosted | Hosted inference provider |
| --- | --- | --- |
| Data path | Your infrastructure | The host's infrastructure and retention policy |
| Cost structure | Hardware and operations, paid whether traffic arrives or not | Per token or per request, no idle cost |
| Version control | You decide when to upgrade | The host decides what it serves and when it changes |
| Limits | What your memory allows | What the host configures for your account |
| License compliance | Entirely yours | Shared with the host under its terms |
| Who pages at 3 a.m. | You | The host, for its part |

Table: The trade-off for the same model. Many teams use both, starting hosted and moving steady workloads in-house.

Hosting options are broad. Hugging Face's Inference Providers documentation lists partners including Baseten, Cerebras, DeepInfra, Fireworks, Groq, Novita, Nscale, OVHcloud, Scaleway, Together and Z.ai behind an OpenAI-compatible router, and describes automatic failover between them when one is flagged unavailable[21]. Most labs also run their own API for their models. For self-hosting, every engine above exposes an OpenAI-compatible server; [self-hosted models behind an OpenAI-compatible endpoint](https://infro.io/blog/self-hosted-vllm-openai-compatible) walks through vLLM in production. The infrastructure side of running them in your own data centre is covered in [on-prem LLM](https://infro.io/blog/on-prem-llm).

## Same weights, different hosts

A hosted open weight model is the model plus the host's choices. Groq's model list shows it plainly: it serves `qwen/qwen3.8-27b` with a 131,072-token context window and marks it Preview, meaning evaluation only and subject to discontinuation at short notice[15]. The model card states 262,144 tokens natively[4]. Neither is wrong; they are different products built on the same weights.

What to check for every host of a model you plan to use:

1. **Context and output limits** as the host configures them, not as the card states.
2. **Precision.** BF16, FP8 and lower formats are not interchangeable for every task.
3. **Chat template and tool-call parsing.** A wrong template or parser turns tool calls into plain text.
4. **Status.** Preview, beta and production carry different promises.
5. **Version pinning.** Whether the host's model id points at a fixed checkpoint or a moving one.

Then measure. [Same open-weight model, different hosts](https://infro.io/blog/open-weight-model-hosting-consistency) publishes a protocol and harness for checking whether two hosts behave the same, starting from run-to-run noise on one host. Pair it with [evaluating on your real workloads](https://infro.io/blog/evaluate-llms-real-workloads) so the comparison uses your prompts, not a benchmark's.

## When open weight models are the right choice

Open weights earn their place when one of these is true:

- **The data path must be yours.** Regulated data, customer contracts or internal policy rule out sending prompts to a third party. Self-hosting is the only option that keeps every byte on your infrastructure.
- **You need a fixed version.** A workflow validated against one checkpoint should not change because a provider updated its model.
- **You want a way out.** A model several hosts serve gives you an alternative when one host has an outage, changes terms or retires the model.
- **You will fine-tune.** Domain adaptation, distillation and specialised variants start from weights.
- **Steady, high volume makes owned capacity pay.** Utilisation decides it; idle GPUs are expensive.

They are a weaker fit when you need the strongest available model on a hard task and a closed model wins your evaluation, when your traffic is spiky and small, or when nobody on the team will own a serving stack or a license review.

## Running open weight models through INFRO

INFRO is a control plane over provider accounts you already hold. For open weight models that means connecting the hosts you chose with your own keys, such as Groq, Together AI, Fireworks AI or a lab's own API, and any server you run that speaks the OpenAI API as an OpenAI-compatible endpoint ([connect a provider](https://infro.io/docs/providers)). Each host bills you directly; INFRO charges a subscription and takes no share of model spend.

A route can then put the same model on two hosts, or a self-hosted server and a hosted one, with failover between them ([routes](https://infro.io/docs/routes)). Model allowlists keep production to the models and licenses your review approved, and every request record names the provider and connection that served it, with its latency and estimated provider cost, so a host-by-host comparison comes from your own traffic. INFRO does not make two hosts behave the same: whether a fallback host is equivalent is still a question your evaluation answers.

## Questions

### Are open weight models free to use commercially?

Many are, but check the exact model. Apache 2.0 and MIT models such as gpt-oss, Gemma 4 and DeepSeek V4.1 Flash allow commercial use with notice requirements. Llama asks for a separate license above 700 million monthly active users, Kimi K3 needs an agreement for large model-as-a-service businesses, and MiniMax M3 requires a notice or written authorization depending on revenue.

### What is the difference between open weights and open source AI?

Open weights gives you the trained parameters. The Open Source AI Definition 1.0 also requires the complete training and inference code and detailed information about the training data, plus the freedom to use the system for any purpose. Most released models meet the first part only.

### Can I run an open weight model on a single GPU?

Smaller ones, yes. OpenAI states gpt-oss-20b runs within 16 GB of memory and gpt-oss-120b fits on one 80 GB GPU thanks to MXFP4 weights; Meta states Llama 4 Scout runs on one H100 with int4 quantization. Models with hundreds of billions or trillions of parameters need a multi-GPU node.

### Is a hosted open weight model the same as running it myself?

Not necessarily. A host chooses the precision, the context limit, the chat template and when to update. Groq, for example, lists a shorter context window for Qwen3.8-27B than the model card. Qualify each host as its own system before relying on it.

## Sources

1. The Open Source AI Definition 1.0 — Open Source Initiative. https://opensource.org/ai/open-source-ai-definition (accessed 2026-10-19)
2. openai/gpt-oss-120b — Hugging Face. https://huggingface.co/openai/gpt-oss-120b (accessed 2026-10-19)
3. openai/gpt-oss-20b — Hugging Face. https://huggingface.co/openai/gpt-oss-20b (accessed 2026-10-19)
4. Qwen/Qwen3.8-27B — Hugging Face. https://huggingface.co/Qwen/Qwen3.8-27B (accessed 2026-10-19)
5. google/gemma-4-31B-it — Hugging Face. https://huggingface.co/google/gemma-4-31B-it (accessed 2026-10-19)
6. mistralai/Mistral-Small-4-119B-2603 — Hugging Face. https://huggingface.co/mistralai/Mistral-Small-4-119B-2603 (accessed 2026-10-19)
7. mistralai/Mistral-Large-3-675B-Instruct-2512 — Hugging Face. https://huggingface.co/mistralai/Mistral-Large-3-675B-Instruct-2512 (accessed 2026-10-19)
8. deepseek-ai/DeepSeek-V4.1-Flash — Hugging Face. https://huggingface.co/deepseek-ai/DeepSeek-V4.1-Flash (accessed 2026-10-19)
9. meta-llama/Llama-3.3-70B-Instruct — Hugging Face. https://huggingface.co/meta-llama/Llama-3.3-70B-Instruct (accessed 2026-10-19)
10. meta-llama/Llama-4-Scout-17B-16E-Instruct — Hugging Face. https://huggingface.co/meta-llama/Llama-4-Scout-17B-16E-Instruct (accessed 2026-10-19)
11. Kimi K3 License — Moonshot AI. https://huggingface.co/moonshotai/Kimi-K3/blob/main/LICENSE (accessed 2026-10-19)
12. GLM-5.3 license — Z.ai. https://huggingface.co/zai-org/GLM-5.3/blob/main/LICENSE (accessed 2026-10-19)
13. MiniMax Community License — MiniMax. https://huggingface.co/MiniMaxAI/MiniMax-M3/blob/main/LICENSE (accessed 2026-10-19)
14. Qwen/Qwen3.8-2.4T-A95B — Hugging Face. https://huggingface.co/Qwen/Qwen3.8-2.4T-A95B (accessed 2026-10-19)
15. Supported models — Groq. https://console.groq.com/docs/models (accessed 2026-10-19)
16. moonshotai/Kimi-K3 — Hugging Face. https://huggingface.co/moonshotai/Kimi-K3 (accessed 2026-10-19)
17. zai-org/GLM-5.3 — Hugging Face. https://huggingface.co/zai-org/GLM-5.3 (accessed 2026-10-19)
18. MiniMaxAI/MiniMax-M3 — Hugging Face. https://huggingface.co/MiniMaxAI/MiniMax-M3 (accessed 2026-10-19)
19. meta-llama models — Hugging Face. https://huggingface.co/meta-llama (accessed 2026-10-19)
20. Gemma 4 collection — Hugging Face. https://huggingface.co/collections/google/gemma-4 (accessed 2026-10-19)
21. Inference Providers — Hugging Face. https://huggingface.co/docs/inference-providers/index (accessed 2026-10-19)