Open Source LLM: Which Models Are Open, and How Open

An open source LLM, in everyday use, is a language model whose trained weights you can download and run yourself. Strictly, most of them are open weights: the training data and recipe stay private. As of 31 October 2026 the permissively licensed picks are Qwen3.8-27B, gpt-oss, Gemma 4, DeepSeek V4 and GLM-5.3-Flash. Kimi K3 and Mistral Large 4 are open too, with conditions on resellers.

Open source or open weights?

The Open Source Initiative publishes a definition of open source AI. It asks for more than the weights: sufficiently detailed information about the training data, the code used to train and run the model, and the parameters, all under terms that let you use, study, modify and share. Very few frontier-scale releases meet that bar, and none of the model cards we read for this page claim to.

What the cards do give you is the weights, the inference code and a licence. That is enough for most buyers, so we use "open source LLM" the way searchers do and say "open weights" when precision matters. The practical question is never the label. It is what the licence lets you do with the files.

The lineup on 31 October 2026

The table below comes from each model's Hugging Face card and API metadata, read on the date above. Parameter counts are the safetensors totals unless the card gives its own figure.

Two things stand out. First, the Chinese labs and Mistral now ship open models well past a trillion parameters, which no single GPU can hold. Second, the permissive licences cluster at two ends: small dense models (Qwen3.8-27B, Gemma 4, gpt-oss) and DeepSeek's very large MoE models under plain MIT.

Licences, in plain words

A licence decides whether you can build a product on the weights. Here is how the ones above differ.

Apache-2.0 and MIT

Use it, change it, sell products built on it, host it for others. Apache-2.0 adds an explicit patent grant. MIT is shorter. Neither asks you to pay or to report revenue. These cover Qwen3.8-27B, gpt-oss, Mistral Small 4, Gemma 4 (the card links Google's Gemma 4 licence page and tags the weights Apache-2.0), DeepSeek V4 and GLM-5.3-Flash.

Custom licences with a reseller condition

Kimi K3's licence text, which we read, starts as an MIT-style grant. It then carves out a "Model as a Service" business, meaning you give third parties inference or fine-tuning access with meaningful control over inputs or parameters. If you run one and your group revenue passes 20 million US dollars over twelve months, you need a separate agreement with Moonshot AI. A second clause asks that "Kimi K3" be shown on the interface of products above 100 million monthly active users or 20 million dollars monthly revenue. Internal use is exempt.

GLM-5.3's licence has the same Model-as-a-Service shape with a far higher line: group revenue over 10 billion US dollars means passing a Z.ai security review first. Mistral's Large 4 licence, which we read, is a modified MIT with a stricter line: any Model-as-a-Service business, at any revenue, needs a separate commercial licence from Mistral. Internal use is exempt, and so is use through Mistral's own products.

Gated licences

Meta's newest open weights are no longer Llama. Muse Spark Open (816B total, 42B active, released 15 October 2026) is gated on Hugging Face. Its licence asks you to display "Built with Muse Spark Open" in each product that uses it, and requires a separate agreement with Meta before offering it as a model-as-a-service business above 20 million US dollars of group revenue.

Llama 4 weights sit behind an access request on Hugging Face and carry the "llama4" licence tag. We could not read the licence text without access, so any threshold or attribution rule stays unconfirmed: . See our Llama page.

What "open" saves you, and what it costs

Open weights give you three things that a closed API cannot.

• Control of the data path. Prompts stay on hardware you choose. For regulated work that is often the whole reason.
• No vendor deprecation clock. Mistral's own docs mark Medium 3.5 as deprecated on its API from 31 October 2026, with Large 4 as the replacement, yet the weights stay downloadable. Kimi says it plans to retire its K2 API models by the end of December 2026. A file on your disk does not retire.
• Price you can model. Your cost is hardware time, not a per-token rate someone else can change.

The costs are real too. A model with hundreds of billions of parameters needs a GPU cluster, a serving engine and someone who can run it. Our open vs closed comparison walks through when the break-even arrives, and cloud vs self-hosted AI covers the operations side.

Three ways to use an open model

1. Hosted by the maker. DeepSeek, Z.ai, Moonshot, Alibaba and Mistral all sell API access to their own weights. You get the model with no hardware, at maker prices. DeepSeek lists deepseek-flash at $0.15 per million input tokens (cache miss) and $0.60 output off-peak, doubled at peak hours, with a 1M context and up to 384K output.
2. Hosted by a third party. The same weights are served by inference platforms, so you can pay per token without running a GPU. See AI hosting, Hugging Face Inference, Cloudflare Workers AI, Replicate and AWS Bedrock. Which models each host carries changes often, so check the host's own catalogue.
3. Self-hosted. Rent GPUs from Runpod, Modal or Lambda, or buy your own, and serve with vLLM or SGLang. The cards for Qwen, DeepSeek, GLM, Kimi and Mistral all give vLLM or SGLang instructions.

What fits on which hardware

Memory is the first filter. Rule of thumb: parameters times bytes per parameter gives the weights alone, before the key-value cache for long contexts. That is our arithmetic, not a card claim, so treat it as a floor.

If you only have a workstation or a Mac, the realistic range is Gemma 4, Qwen3.8-27B and gpt-oss-20b. For tooling on that path read Ollama vs LM Studio and Ollama vs vLLM.

Coding with an open model

Most coding agents accept a custom model endpoint. DeepSeek's own docs list Claude Code, Codex, OpenCode and OpenClaw as supported front ends, using either an OpenAI-format or an Anthropic-format base URL. Moonshot's K3 API is documented as OpenAI and Anthropic compatible. Mistral ships its own Vibe CLI that targets Mistral models and local vLLM servers. For agent-by-agent notes see OpenCode, Claude Code and Cline. If code is your main use, go straight to the best open source LLM for coding.

Published scores, and how to read them

Every score below is vendor-reported on the maker's own model card. Harnesses, effort levels and test sets differ between cards, so do not mix columns across rows.

The same cards also print closed-model columns (Claude Opus, GPT-5.6 Sol, Fable 5), which is a useful sanity check but still the maker's own run. We have not reproduced any of these numbers.

Which one to pick

Moving from a closed API to an open model

Most open models are served behind an OpenAI-style chat endpoint, so the code change is small: swap the base URL, the key and the model name. DeepSeek, for one, documents both an OpenAI-format and an Anthropic-format base URL, which means a tool written for either vendor can point at it.

The behaviour change is larger. Reasoning models return their thinking in a separate field, and several cards ask you to pass that field back on the next turn. Kimi K3's card says it was trained with preserved thinking history and needs the full assistant message, reasoning content included, returned as-is. Qwen3.8 keeps thinking blocks from earlier messages by default. If you strip those fields in a shared client library, quality drops and you will blame the model.

Sampling matters as well. The cards recommend temperature 1.0 for most of these models, with top_p between 0.95 and 1.0 depending on the task. Copying a temperature of 0.2 from an old closed-model setup is a common reason an open model looks worse than its published scores.

Common mistakes

• Treating the licence tag as the licence. Three of the models above show only "other" on Hugging Face and have materially different files behind it.
• Sizing for the weights and forgetting the cache. A 1M-token context needs far more memory than the parameter count suggests. Plan for the context you will use, not the maximum printed on the card.
• Comparing scores across harnesses. A Terminal Bench figure run in Claude Code is not the same test setup as one run in a vendor's own harness.
• Ignoring the maker's own API. If you are not bound to self-host, the maker's API is often the cheapest way to try the exact released weights, and it tells you what the model does before you rent a cluster.

A short checklist before you commit

1. Read the LICENSE file, not just the Hugging Face tag. "other" hides very different terms.
2. Check the context window you will really use. Native and extended lengths differ: Qwen3.8-27B is 262,144 native and needs YaRN settings for 1M.
3. Price both routes. Compare the maker's API rate with an hourly GPU rate and your real tokens per day.
4. Confirm the serving engine supports the model today. New architectures often need a recent vLLM or SGLang build.
5. Test on your own tasks. A table of vendor scores is where you start, not where you stop.

Our take

If the question is simply "which open model should I try first", we would start with Qwen3.8-27B for local and single-GPU work and DeepSeek V4.1 Flash through its API for scale. The reason is documentation, not folklore: both are under plain licences, both publish serving recipes, and the Flash API rate is low enough that testing costs little. Choose GLM-5.3 or Kimi K3 when you want the top end and have read the revenue clauses. Compare prices across all of them on LLM API prices or the model comparison tool.

Product names are used descriptively. We are not affiliated with any model maker named here.