10 best open source AI models in 2026, and what each is for

Most lists of the best open source AI models rank them by benchmark score. That score is close to useless for choosing one. What decides whether a model can go into your product is the licence it ships under and the memory it needs to run, and neither of those appears on a leaderboard.

I have two products in production where a language model does the central work. Recuvix generates SEO-structured blog drafts. NovaEdge News ingests Hindi RSS feeds, rewrites each item and publishes on a schedule with nobody operating it. In both, the model was a smaller decision than the pipeline around it, and the licence was a bigger one than I expected.

So this is ten open weight models grouped by the job they are good at, with the licence written next to each one. Version numbers in this category move every few months. The families have held their positions for longer than the versions have, so where I name a version, open the model card and check it before you pin anything.

How I picked these

Four questions, in this order. Does the licence survive a client's legal review. Are the weights published at a size I can serve. Does the model hold a chain of tool calls together without losing the thread. Is there a smaller sibling in the same family, so a cheap pass and an expensive pass can share one prompt format.

Benchmark scores are missing from that list. They are usually published by the people shipping the model, they move with every release, and a model that scores two points higher and does not fit on your GPU has not helped you.

1. Qwen, for the widest range of sizes

Alibaba's Qwen family runs from under a billion parameters up to a 235B mixture-of-experts model, all of it Apache 2.0. That range is why it is my default. You can prototype against the large one, ship an 8B for the passes that need less, and keep one prompt format across both.

It is also the family most other people's fine-tunes start from, so when you hit a problem, somebody has usually written down what it was. The Coder and VL variants cover code and vision without leaving the family.

Where it costs you: the ladder is wide enough that it is easy to ship a size too small for the job and then blame the prompt.

2. DeepSeek, for reasoning you can read

DeepSeek publishes under MIT, the most permissive licence on this list, and DeepSeek-R1 was the release that put open reasoning models into production. It published the reasoning traces instead of hiding them, and the distilled versions brought that behaviour down to sizes that fit on one card.

The full model is a mixture-of-experts in the region of 671B total parameters with roughly 37B active per token. That is a data-centre model. Most people will use a hosted endpoint or one of the distills.

Where it costs you: if your data cannot leave your hardware, the full-size version is out of reach and you are choosing a distill, which is a smaller model with a family resemblance rather than the thing you read about.

3. gpt-oss, for one GPU and a licence nobody argues about

OpenAI's gpt-oss models arrived in August 2025 as the first open weights from that lab since GPT-2, under Apache 2.0. The 120b fits on a single 80GB card and the 20b runs on a 16GB machine, which makes the pair unusually easy to plan hardware around.

For a client who wants a permissive licence and a vendor name their board already recognises, this is the shortest conversation on the list.

Where it costs you: it is text only. Anything that has to read a screenshot, a scanned invoice or a photograph needs a different model.

4. Llama, for the ecosystem rather than the score

Meta's Llama is here because of gravity. Quantizations appear for it first, serving guides assume it, and most fine-tuning tooling was written against it. That saves days of work, and days of work is a better reason than a benchmark.

It is not OSI open source. The community licence attaches conditions: past 700 million monthly active users you need a separate agreement with Meta, and derivative model names have to carry the Llama name.

Where it costs you: it has the weakest licence here, and on capability alone it is no longer the family I would reach for.

5. Mistral Small, for the work that is most of the work

Mistral Small sits in the 24B class under Apache 2.0, and it is what I would put behind the boring passes: classification, extraction, rewriting, routing a request to the right handler. Most of what a product asks a model to do is that rather than hard reasoning.

Devstral covers coding agents and Magistral covers reasoning, both from the same lab, so the family scales without a new prompt format. Mistral also offers European hosting, which settles the question for some clients before anything technical comes up.

Where it costs you: hand it a genuinely hard reasoning problem and it will give you something fluent and wrong.

6. Gemma, for small multimodal and on-device

Google's Gemma runs at 4B, 12B and 27B with vision from 4B up and a 128K context window. It is the easiest way to get multimodal work onto one consumer GPU or a phone.

It ships under Google's own Gemma licence rather than Apache 2.0. The weights are free to use commercially, and there is a use policy attached that a strict legal review will read line by line.

Where it costs you: that licence. If the review on your project is strict, an Apache 2.0 or MIT model saves you a conversation you do not need to have.

7. Kimi K2, for long chains of tool calls

Moonshot AI's Kimi K2 is a mixture-of-experts model around a trillion total parameters with roughly 32B active, built for agentic work. On a task that runs twenty tool calls deep, it is the open weight model I would trust to still know what it was doing at call eighteen.

The licence is a modified MIT that adds an attribution condition once a product built on it gets large, so read that clause instead of assuming plain MIT.

Where it costs you: self-hosting a trillion-parameter model is a procurement project rather than a decision. In practice you are renting it from somebody.

8. GLM, for coding agents on a budget

Z.ai's GLM family is MIT licensed and aimed at code and agent work. The large one runs around 355B total parameters with 32B active. The Air variant, roughly 106B total and 12B active, is the size most teams should look at first, because it fits on hardware you can rent by the hour.

Where it costs you: the tooling and the community around it are thinner than Qwen's, so you will read more source code and find fewer answers already written down.

9. Whisper, still the default for speech

Whisper is MIT licensed, several years old, and still the first thing I install for speech to text. The large variants give you accuracy, the distilled and turbo variants give you throughput, and the multilingual coverage is why NovaEdge News can work from Hindi sources at all.

Where it costs you: it invents text on silence. Feed it a recording with long quiet stretches and it will fill them with plausible sentences, so put voice activity detection in front of it and treat that as part of the model rather than as an optimisation.

10. OLMo, when you have to know what it was trained on

The Allen Institute for AI publishes OLMo under Apache 2.0 with the training data and the training code alongside the weights. It is the only family here that answers the question of what is inside it with a link rather than a shrug.

That matters for research, for audits, and for a client in a regulated industry who has to say something specific about where the training data came from.

Where it costs you: it does not match Qwen or DeepSeek on capability. You pick it when the audit matters more than the score.

Image, video and embedding models

Three categories that did not get a numbered slot and belong on any working list. For images, Black Forest Labs' FLUX.1 and Alibaba's Qwen-Image, with Stable Diffusion 3.5 still in wide use. For video, Alibaba's Wan models. For embeddings, Qwen3-Embedding and BGE-M3 cover most retrieval work.

The licence trap lives here rather than in the language models. FLUX.1 schnell is Apache 2.0 and FLUX.1 dev is not licensed for commercial use, and dev is the one people benchmark, like, and then quietly ship. Check which variant you downloaded.

The licence is the part people skip

Almost nothing on this list is open source in the sense the term originally meant. Open source would cover the training data and the code that produced the weights. What these labs publish is the weights under a licence they wrote themselves, which is why open weights is the more accurate phrase for nine of the ten. OLMo is the exception.

The distinction has practical edges. Apache 2.0 and MIT let you use the model commercially, modify it, and ship it inside a product with no user threshold: Qwen, DeepSeek, gpt-oss, Mistral Small, GLM and OLMo. Llama, Gemma and Kimi each attach conditions, and those conditions are short enough to read in the time a checkpoint takes to download.

A benchmark score tells you which model you would like to ship. The licence tells you which one you are allowed to.

The reason to check this before anything else is asymmetry. Swapping a model after launch costs you a week of prompt work. Finding out after launch that you were never allowed to ship the one you built on costs you the launch.

What runs on your hardware

Whether you can self-host comes down to bytes rather than parameter count. The arithmetic is short enough to do in your head.

# Weights only, before context and KV cache.
# params (billions) x bytes-per-param = GB
#
#   fp16   2.0 bytes     32B ->  64 GB
#   int8   1.0 bytes     32B ->  32 GB
#   int4   0.5 bytes     32B ->  16 GB
#
# A 235B model at int4 is still about 118 GB.

The line people get wrong is the mixture-of-experts one. A model advertised at 32B active still needs every expert resident, so a 355B model with 32B active occupies the memory of a 355B model and runs at roughly the speed of a 32B one. The active count is a speed number. The total is the number your GPU cares about.

Add context and KV cache on top of that table, then leave headroom. A long-context request on a card with none left is the failure that turns up in production rather than in testing.

How I choose in one pass

If the data can leave your hardware, start with a hosted endpoint serving Qwen or DeepSeek and stop optimising. Somebody else is running those GPUs at a price you cannot match at your volume.

If the data cannot leave, size the hardware first and choose from whatever fits. That one constraint usually cuts the list to two or three.

Then the specifics. Long tool chains, Kimi or GLM. Reads images, Gemma or Qwen VL. Strict legal review, Apache 2.0 or MIT only. Has to explain its training data, OLMo. Speech, Whisper.

What I would tell someone starting

Start with the small model. A 4B to 8B model handles extraction and rewriting, and that is most of what products ask a model for. Reaching for the largest one first hides the fact that your prompt is vague.

Build the pipeline before you tune the model. There is a separate post on this blog about the model call being the cheap part of an AI feature, and every line of it applies harder once the weights are yours to serve.

Then pin the version. A model that changes under you is worse than a weaker model that holds still, because a quality drop you cannot date is a quality drop you cannot fix.