Llama 4 vs Mistral vs DeepSeek vs Qwen3: Which Open-Source LLM Should You Self-Host?

If you've gone looking for "the best open-source LLM" this year, you've probably landed on a listicle ranking Llama, Mistral, DeepSeek, and Qwen by a benchmark score that moves every six weeks. That ranking answers the wrong question. The question that actually decides which model ends up in your product isn't "which one scores highest" — it's "which one can I legally and practically run for what I'm building." Those are license questions and hardware questions, and almost nobody writing about these models answers them plainly. Here's the real comparison.

"Open Weight" Is Not the Same as "Open Source"

All four model families publish their weights for anyone to download. Only some of them are open source in the legal sense that lets you use them however you want.

Llama 4 ships under Meta's own Llama 4 Community License, not an OSI-approved open-source license. Read the actual text in Meta's license repo and Section 2 says plainly: if your product or service had more than 700 million monthly active users in the month before a Llama 4 release, you need Meta's separate written permission before you can use it at all. For nearly every team reading this, that clause is irrelevant — but it's the reason Llama is correctly called "open weight," not open source, and why some enterprise legal teams won't sign off on it.

Mistral and Qwen take the opposite approach. Mistral Large 3 and the Qwen3 family are both released under Apache 2.0 — no user-count ceiling, no field-of-use restriction, free for commercial use including fine-tuning and resale. DeepSeek splits the difference: the DeepSeek-V3 repo licenses the inference code under MIT, while the model weights carry their own Model License that explicitly permits commercial use, just not the blanket Apache terms.

If your product might ever get acquired, white-labeled, or scaled past the threshold where a vague license becomes legal's problem, this is the first filter — before you look at a single benchmark.

The Four Models, By the Numbers

All four current flagships are Mixture-of-Experts (MoE) architectures, which matters for cost: an MoE model only activates a fraction of its total parameters for any given token, so inference cost and speed track the *active* parameter count, not the total one.

• **Llama 4 Maverick** (Meta) — a 400B-total MoE with 17B active parameters per token, available via Ollama in Scout and Maverick configurations.
• **Mistral Large 3** (Mistral AI) — 675B total, 41B active, with a 256k token context window and a built-in vision encoder for multimodal input.
• **DeepSeek-V3** — 671B total, 37B active (685B including its multi-token-prediction module), the model that put reasoning-per-dollar on the map when it shipped.
• **Qwen3** (Alibaba) — the broadest family of the four, spanning dense and MoE variants from 0.6B all the way to 235B, so it's the only one that genuinely scales down to a laptop.

Four different companies, four different bets: Meta is optimizing for ecosystem lock-in around its own license, Mistral for the cleanest enterprise legal story, DeepSeek for inference efficiency, and Qwen for sheer breadth of deployable sizes.

What You Can Actually Run on Your Own Hardware

This is where most "which LLM should I use" posts quietly stop being honest, because the flagship number in a headline and the model you can actually run on a single GPU are not the same model.

VRAM need scales roughly as parameters × bytes-per-parameter — FP16 at 2 bytes, down to roughly 0.6 bytes at 4-bit quantization (Q4), the format most people actually run locally. Hugging Face's quantization documentation covers the tradeoff in more depth, but the practical upshot is simple: quantizing a model to Q4 cuts its memory footprint to roughly a quarter of full precision with only a small, usually acceptable, quality loss.

Put concretely: a 24GB consumer GPU (an RTX 4090, for instance) comfortably runs Qwen3's 30B-A3B MoE variant or Mistral's smaller Small-class models at Q4. The actual flagships in the list above — Llama 4 Maverick, Mistral Large 3, DeepSeek-V3 — are 400B-to-675B-parameter MoE models that need to hold *every* expert in memory even though only a fraction activates per token, which is why they typically require multi-GPU servers or a cloud instance, not a desktop. If your plan is genuinely local, single-GPU inference, you're choosing among the smaller Qwen3 and Mistral variants, not the headline flagship — and that's fine, because for most product use cases a well-chosen 14B–32B model is plenty.

Pulling Any of These With Ollama

Once you've picked a size that actually fits your hardware, running it locally is the easy part. Ollama is the open-source tool most teams use for this — it handles quantized weight downloads, exposes a local REST API, and ships OpenAI-compatible tool-calling support, which is what lets you swap a hosted model for a local one in an existing codebase without rewriting your integration. A `qwen3:30b` or `deepseek-r1` pull from the Ollama library is a one-line command; the model card there shows you exactly which quantization and RAM tier you're getting before you download it. If you also want a ChatGPT-style interface on top of whatever you pull, we covered pairing Ollama with Open WebUI as a free, self-hosted chat front end in an earlier post.

So Which One Should You Actually Pick?

If your product has to clear a strict legal review before it ships, start with Mistral or Qwen and only reach for Llama if you have a specific reason — its ecosystem is large, but the license adds friction a legal team may not want to deal with. If you're optimizing hard for inference cost at scale and can run a real GPU cluster, DeepSeek-V3's active-parameter efficiency is worth the evaluation. If you're building something that genuinely needs to run on a single developer machine or a modest cloud box, Qwen3's smaller MoE variants are, as of now, the most complete size ladder of the four. None of this is a permanent ranking — it's a snapshot, and the honest answer six months from now may differ as each lab ships its next release.

Picking a model is one decision inside a much longer chain: how you serve it, how you cache and route requests between a cheap local model and an expensive frontier one, how you evaluate whether the swap actually held up quality, and how you keep API or inference costs from quietly eating your margin as usage grows. That's the real work of AI Product Development Bootcamp — not picking a model name off a leaderboard, but the architecture decisions around RAG, fine-tuning, and model selection that determine whether an AI feature survives contact with real users and a real budget. If you're also weighing whether to fine-tune instead of swapping models, our breakdown of when fine-tuning actually beats RAG is the natural next read.