What Are Open Weight Models? 8 Worth Running in 2026

October was a busy month for open weights. Meta, StepFun, and DeepSeek all published new models within three days of each other, and the strongest weights you can download now trail the top closed model by about 15 points on the Respan Index.

Downloading the weights is the easy part, though. The license decides whether you can ship a product on them, and the model's size decides whether you need one GPU or a multi-GPU node, so those two questions usually narrow the field faster than any benchmark.

Below is what open weight models are, how they differ from open source, and 8 open weight models worth running in 2026.

What is an open weight model?

An open weight model is a trained model whose weights, the learned parameters that turn input into output, are published for anyone to download. With the weights, you can run the model on your own hardware, fine-tune it on your data, quantize it to fit smaller GPUs, and serve it without sending requests to the lab that trained it.

What usually doesn't come with them is the training data, the code used to produce them, and any tools or features the lab adds to its hosted version. The license then decides what you can do commercially. Some labs use standard licenses like MIT and Apache 2.0, while others write custom licenses with conditions that apply once a company or product passes a certain size.

Open weight vs open source

The Open Source Initiative, which maintains the definition of open source software, sets a higher bar for calling an AI system open source. Its definition requires three components: the parameters, the code used to train and run the system, and enough information about the training data for a skilled person to build a substantially equivalent system. Open weight releases usually include only the first, so by that definition, most of the models people call open source LLMs are open weight.

In everyday use the two terms get treated as interchangeable, and for running or fine-tuning a model, that's mostly harmless, since the weights and the license are what you work with. The difference matters when you need to audit what a model learned from or reproduce how it was trained, because neither is possible without the data and training code.

Open weight models compared by license and hardware

The license sets what you can do commercially, and the parameter count is the quickest signal of the hardware a model needs.

Parameter counts come from each model's card. DeepSeek's card for V4.1 Flash 1017 lists 763B total parameters without an active count, and GLM-5.3's configuration matches GLM-5, which Z.ai lists at 744B total and 40B active.

Open weight models with permissive licenses

These five use MIT or Apache 2.0, which allow commercial use with no conditions beyond keeping the license notice. Within the group, higher Respan Index scores come first.

1. DeepSeek V4.1 Flash 1017

DeepSeek V4.1 Flash 1017 is the October 17 update to DeepSeek's Flash model, and it ships under MIT, so you can run, modify, and build products on it without conditions beyond the notice. It takes text and image input with a 1M-token context, and DeepSeek's card lists 763B total parameters.

That size means even the 8-bit weights run to roughly 760 GB, so this is a multi-GPU deployment. The card lists vLLM, SGLang, and Docker Model Runner, and instead of a Jinja chat template, DeepSeek ships a Python encoding script plus deepseek-recipe, a Rust library for formatting prompts in production, so check that your serving stack handles it. DeepSeek's API serves this same version under the deepseek-flash name, which makes it easy to compare self-hosted output against the hosted model. It has the highest Respan Index score of the eight, at 59.4.

• License: MIT
• Serve with: vLLM, SGLang, or Docker Model Runner
• Run it if: You want the highest-scoring weights here with no license conditions

2. MiMo-V2.6-Pro

Xiaomi's MiMo-V2.6-Pro takes text, image, video, and audio input in a single model, with 1.02T total and 42B active parameters and a 1M-token context. Like DeepSeek's model, it's MIT-licensed, which puts no conditions on commercial use beyond the notice.

Xiaomi's card doesn't list hardware requirements, but its example SGLang launch spreads the model across two nodes with 16-way tensor parallelism, which gives a sense of the scale involved. SGLang is the engine Xiaomi recommends for best performance, with vLLM and Transformers also supported, and the same model is available through Xiaomi's API and OpenRouter if you'd rather test it before committing hardware. It scores 56.1 on the Respan Index.

• License: MIT
• Serve with: SGLang (recommended) or vLLM
• Run it if: Your agents work with images, video, or audio and you want MIT terms

3. Qwen3.8-27B

Qwen3.8-27B is a 27B dense model under Apache 2.0 that understands text, images, and video, with a native 262,144-token context that extends to 1M with YaRN. Apache 2.0 allows commercial use and modification and includes an explicit patent grant.

Its BF16 weights take about 54 GB, so it fits on a single 80 GB GPU before you quantize it at all, and the community has published quantized builds for llama.cpp, Ollama, and LM Studio. Qwen Cloud's hosted version, listed as coming soon, adds a 1M context by default and built-in tools, and its API takes some parameters differently, such as passing enable_thinking directly. It scores 42.1 on the Respan Index, well above Gemma 4 and gpt-oss, the other two models here built for single-machine use.

• License: Apache 2.0
• Serve with: vLLM, SGLang, or Transformers, with BF16 weights
• Run it if: You want a capable model on one GPU that you can fine-tune freely

4. Gemma 4

Google's Gemma 4 family runs from phones to servers: E2B and E4B for phones and laptops, a 12B Unified model, a 26B A4B mixture-of-experts model, and a 31B dense model. All five sizes are Apache 2.0, all take images, and the three smallest also take audio.

Google targets the 12B, 26B A4B, and 31B sizes at consumer GPUs and workstations, and the community has published hundreds of quantized builds for llama.cpp, Ollama, and LM Studio. The 12B Unified model is built so the entire model can be fine-tuned in one pass. Its benchmark results are modest, at 18.6 on the Respan Index for the 31B, so Gemma earns its place on reach and license rather than raw capability, and the Gemma vs Gemini comparison covers when the open weights beat Google's hosted models.

• License: Apache 2.0
• Serve with: Community quantized builds for llama.cpp, Ollama, or LM Studio
• Run it if: You need a model on a phone, a laptop, or a single workstation GPU

5. gpt-oss-120b

OpenAI's gpt-oss-120b is a 117B-total, 5.1B-active model under Apache 2.0, released in August 2025, which makes it the oldest model here. OpenAI describes the license as letting you build freely without copyleft restrictions or patent risk.

OpenAI says it fits on a single 80 GB GPU such as an H100 or MI300X, because its mixture-of-experts weights were post-trained in MXFP4, and the smaller gpt-oss-20b runs within 16 GB of memory. Fine-tuning fits modest hardware too, since OpenAI says the 120b fine-tunes on a single H100 node and the 20b on consumer hardware. The catch is the format: both models only work correctly with OpenAI's harmony response format. It scores 16.5 on the Respan Index.

• License: Apache 2.0
• Serve with: vLLM, SGLang, Ollama, or LM Studio, with MXFP4 weights
• Run it if: You need one-GPU serving and fine-tuning under a permissive license

Open weight models with license conditions

These three use custom licenses that are permissive for most teams but add terms once a company or product passes a size threshold. All three score above 52 on the Respan Index, and the full field ranked by benchmark shows where they sit against the other open models.

6. Kimi K3

Moonshot AI's Kimi K3 is the largest model here, at 2.8T total and 104B active parameters, with image and video understanding and a 1M-token context. The Kimi K3 License starts from MIT and adds two conditions: a company whose model-as-a-service business has more than $20M in revenue over 12 months needs a separate agreement with Moonshot, and products with more than 100M monthly active users or $20M in monthly revenue must display "Kimi K3" in their interface. Internal use is exempt, and so is using the model through Moonshot's own products or certified inference partners.

Moonshot ships the weights in MXFP4 with MXFP8 activations, produced with quantization-aware training, and lists vLLM, SGLang, and TokenSpeed for serving. One detail can break custom integrations: the model was trained to keep its reasoning history, so multi-turn and tool-call conversations have to send back the full assistant message, including its reasoning content. It scores 53.0 on the Respan Index.

• License: Kimi K3 License
• Serve with: vLLM, SGLang, or TokenSpeed, with MXFP4 weights
• Run it if: You need image and video understanding and your product stays under the license thresholds

7. Qwen3.8 (2.4T-A95B)

Qwen3.8-2.4T-A95B is the open checkpoint behind Alibaba's hosted Qwen3.8-Max, with 2.4T total and 95B active parameters. Its license requires products with more than 100M monthly active users or $20M in monthly revenue to display the model name, and companies running a model-as-a-service or AI Work Assistant business, meaning an AI coding or office productivity product, need a separate license above $50M in revenue over 12 months. Internal use is exempt.

Qwen3.8 shows the gap between open and hosted versions clearly. The open weights are text-only and require thinking mode on every request, while the hosted Qwen3.8-Max adds image input, a non-thinking mode, a 1M context by default, and built-in tools. The open checkpoint has a native 262,144-token context that extends to about 1M, and Qwen points to vLLM, SGLang, and TokenSpeed for serving. Independent evaluators tested the hosted version, which scores 52.9 on the Respan Index.

• License: Qwen3.8-Max License
• Serve with: vLLM, SGLang, or TokenSpeed
• Run it if: You need text-only agents at frontier scale and can work without the hosted version's extras

8. GLM-5.3

Z.ai's GLM-5.3 has the lightest conditions in this group. Its license reads as MIT with one addition: a company running a model-as-a-service business with more than $10B in revenue over 12 months must pass a Z.ai security review before commercial use, and end-user products that embed the model in specific features don't count as model-as-a-service. It has 744B total and 40B active parameters, text-only input, and a 1M-token context with up to 128K output tokens.

Z.ai's card lists a long set of serving options, including SGLang, vLLM, TokenSpeed, KTransformers, and Unsloth, plus Ascend NPU deployment for teams running outside Nvidia hardware. Two defaults are worth changing: reasoning effort starts at "max," and Z.ai recommends turning on clear_thinking for chat use. It scores 52.1 on the Respan Index.

• License: GLM-5.3 License
• Serve with: SGLang, vLLM, or KTransformers, with FP8 weights
• Run it if: You want frontier-scale weights with conditions that only reach the largest companies

What you get with the weights, and what you don't

A set of weights gives you the trained parameters, a model card, a license, and usually the configuration needed to serve them. With those, you can run the model on hardware you control, keep prompts and outputs inside your own infrastructure, fine-tune on your data, and quantize the weights to fit smaller GPUs, which is one of the main ways to optimize AI models you host yourself.

What you don't get is the process that produced them. The models here generally don't publish their training data or training code, so you can't audit what a model learned from or reproduce its training. The hosted version can also differ from the weights: Qwen3.8's open checkpoint is text-only while the hosted Qwen3.8-Max adds image input and built-in tools, and most other labs don't document whether their API matches the open release. Before you assume the weights behave like the API you tried, test the checkpoint itself.

The weights are free, but running them isn't. At 8 bits, each billion parameters takes about a gigabyte of GPU memory before you account for the KV cache, so a 744B model like GLM-5.3 needs a multi-GPU node, while gpt-oss-120b fits on one 80 GB card.

How to self-host open weight models

Self-hosting usually starts with a serving engine. vLLM and SGLang appear on most of the model cards above, and both expose an OpenAI-compatible API, so most applications can point at a self-hosted model by changing a base URL. The work after that is routing and visibility: falling back when a node goes down, splitting traffic between your own GPUs and a hosted API, and knowing what each request cost and whether the output was any good.

Respan's open-source gateway, currently pre-alpha, runs on your own infrastructure next to your models. A single binary lets any SDK call any model, and you turn on routing, fallbacks, and MCP in one config file. When you want every request traced, priced, and scored, turn on the Respan plugin to send them to the hosted platform.

• Self-hosted and hosted models behind one endpoint - vLLM and Ollama are built-in providers alongside OpenAI, Anthropic, Gemini, and DeepSeek, and any OpenAI-compatible endpoint works with a base URL.
• Fallbacks across your GPUs and hosted APIs - Ordered fallback and retries move traffic to the next model on your list when a self-hosted node errors or goes down.
• Traces, cost, and evals in the platform - Each request becomes a trace in Respan with its latency and cost, and you can build a dataset from real requests and run an experiment that scores two open weight models against each other.
• A hosted route when you don't want to run GPUs - Respan's LLM gateway routes 1,000+ models through one API, including hosted versions of DeepSeek, Kimi, GLM, and Qwen.

Respan also publishes open weights of its own. Span-02, a decision model that returns calibrated probabilities over a set of choices, is a fine-tune of Gemma 4 26B A4B released under Apache 2.0, and Span-02's weights run on a single GPU such as an RTX 5090. It belongs with open-weight decision models rather than the general-purpose models above.

FAQ

What is the best open-weight AI model?

Among models with published weights, DeepSeek V4.1 Flash 1017 has the highest Respan Index score, at 59.4 as of November 4, 2026, and it ships under MIT, which also puts it first among the open-weight Claude Opus alternatives. For a model you can run on one machine, Qwen3.8-27B scores 42.1 under Apache 2.0. If license freedom matters most, any of the five MIT and Apache 2.0 models above can be used commercially with no conditions beyond the notice.

Are open-weight models free?

The weights are free to download, and the MIT and Apache 2.0 models here are free to use commercially. Custom licenses like Kimi K3's and Qwen3.8's add conditions above set revenue or user thresholds. What you pay for is compute, either the GPUs to serve the model yourself or the per-token price of a hosted API that serves it for you.

Are open-weight models cheaper?

Through a hosted API, they often are. DeepSeek charges $1.20 per 1M output tokens at peak for V4.1 Flash 1017, and Respan's cheapest LLM APIs ranking shows how open and closed models compare on price. Self-hosting is cheaper only when your GPUs stay busy, since you pay for the hardware whether or not requests arrive. Because Respan logs the cost of every request by model, you can compare a self-hosted model against a hosted API on your own traffic before you decide.