Ollama Default Llama vs Default Qwen — Which Wins Out-of-Box
Last updated 2026-07-01
Type ollama run llama and ollama run qwen with zero tuning and you get two very different models. We benchmarked the defaults to find the real winner.
By Mohamed Meguedmi · 8 min read
Key Takeaways
- Out of the box, Qwen wins on reasoning and code.
ollama run qwen3hands you an 8B model that beats the 3B you get fromollama run llama3.2on almost every quality axis — for roughly 2× the VRAM. - The default tags are not size-matched. Ollama's convenience aliases give a beginner a 3B Llama and an 8B Qwen, so the "default vs default" fight is lopsided before you type a second command.
- Both share the same silent trap: a 4096-token default context and Q4_K_M quantization. Neither enables long context automatically.
- Qwen3 ships hybrid thinking mode; Llama 3.x does not. For math and multi-step logic, that single default is the biggest out-of-box gap.
- Verdict: for a first run with no tuning, Qwen3 is the better default. Pick default Llama only when ≤4GB VRAM or maximum tokens/sec is the hard constraint.
You install Ollama, and within a minute the quickstart tells you to run a model. The two names every developer reaches for first are llama and qwen. But out of the box is doing a lot of quiet work in that sentence. The tag Ollama resolves, the quantization it downloads, the context window it silently caps, and whether reasoning is switched on by default all differ between the two families — and all of it happens before you ever open a config file.
This guide compares exactly what you get from the unmodified first-run commands as of July 2026: ollama run llama3.2 versus ollama run qwen3. Every number below comes from the BestLLMfor benchmark harness running on a single 24GB consumer GPU, and every figure is queryable through our free public API (CC BY 4.0) and the open-source MCP server.
The default tags: what you really pull
Ollama uses short aliases that resolve to a specific size and quantization. Newcomers assume the two commands pull comparable models. They do not.
ollama run llama3.2resolves to the 3B dense build at Q4_K_M — a ~2.0GB download. See the official llama3.2 library page.ollama run qwen3resolves to the 8B dense build at Q4_K_M — a ~5.2GB download. See the official qwen3 library page.
That is a 2.6× parameter gap decided entirely by the default tag. A reader typing the two "obvious" commands is not running a fair fight — they are handed a lightweight edge model on one side and a mid-tier generalist on the other. The first thing to internalize about Ollama defaults is that the alias, not your hardware, chooses the weight class.
| Attribute | ollama run llama3.2 | ollama run qwen3 |
|---|---|---|
| Resolved build | Llama 3.2 3B | Qwen3 8B |
| Architecture | Dense | Dense |
| Default quantization | Q4_K_M | Q4_K_M |
| Disk footprint | 2.0 GB | 5.2 GB |
| Min VRAM (4k ctx) | ~3.5 GB | ~6.6 GB |
| Default context | 4096 | 4096 (40960 native) |
| Thinking mode default | None | Hybrid (on) |
| Native tool calling | Yes | Yes |
Default quantization and context: the shared trap
Whatever you pull, Ollama serves Q4_K_M by default — roughly 4.5 bits per weight, the standard GGUF quant you get from ollama pull. It is a sensible balance of quality and size, and it is identical for both families, so quantization is not a differentiator here. What surprises people is the context window.
By default Ollama caps generation context at 4096 tokens regardless of the model's native capability. Qwen3 8B natively supports 40,960 tokens, but until you set num_ctx (via a Modelfile, an API parameter, or /set parameter num_ctx in the CLI) you are using a fraction of it. Llama 3.2 3B supports up to 128k natively yet is capped the same way. In other words, both defaults ship long-context capable and long-context disabled. If your first-run test involves pasting a large file and the model "forgets" the top, this default — not the model — is the cause.
Out-of-box lesson: the quant is the same, the context cap is the same, and both are conservative. The real quality difference lives in the weights, not the serving defaults.
Quality out of the box: benchmarks with zero tuning
We ran both default builds through our standard suite at Q4_K_M with the default 4096 context, no system prompt tuning, greedy-ish sampling left at Ollama defaults. The 8B Qwen is expected to beat the 3B Llama — the interesting part is the margin.
| Benchmark | Llama 3.2 3B (default) | Qwen3 8B (default) |
|---|---|---|
| MMLU (5-shot) | 60.5 | 76.9 |
| HumanEval (code) | 47.6 | 84.8 |
| GSM8K (math) | 71.2 | 89.4 |
| IFEval (instruction) | 77.4 | 83.9 |
The coding gap is the headline: +37 points on HumanEval. That is consistent with the broader pattern the SERP already reflects — Qwen consistently edges Llama on code and math while staying competitive on general knowledge. The Qwen3 numbers also benefit from thinking mode being on by default, which we cover below. For the underlying model card and evaluation details, see Qwen3-8B on Hugging Face and the Qwen3 technical report.
If you have more headroom, the fairer heavyweight matchup is Llama 3.3 70B versus Qwen3 32B — both land around Q4_K_M near 20–22GB. There the race tightens: Llama 3.3 70B closes most of the general-knowledge gap, while Qwen3 32B keeps its lead on code and structured reasoning. But that is no longer an out-of-box comparison, because neither is the model the default alias pulls. You can explore the full size ladder in our model catalog and side-by-side scores in the benchmarks hub.
Speed, VRAM, and disk footprint
Quality is only half of the first-run experience. On identical hardware the smaller Llama is dramatically faster and lighter, which is exactly why it exists as the default 3B.
| Metric (24GB GPU, Q4_K_M) | Llama 3.2 3B | Qwen3 8B |
|---|---|---|
| Generation speed | ~138 tok/s | ~71 tok/s |
| First-run VRAM (4k ctx) | 3.5 GB | 6.6 GB |
| Disk download | 2.0 GB | 5.2 GB |
| Cold start to first token | <1 s | ~1.5 s |
| Runs on 6GB GPU? | Yes | Tight / no |
Default Llama is close to 2× the throughput and fits comfortably on a 6GB laptop GPU or even CPU-only. Default Qwen wants a bit more — 8GB of VRAM is the comfortable floor once you raise the context past the 4096 default. For anyone on integrated graphics or an older 4–6GB card, the default Llama is the one that actually starts without swapping.
Thinking mode, tool calling, and templates
The most consequential default that is not about size is reasoning. Qwen3 ships with hybrid thinking enabled: it emits an internal reasoning pass before the answer and can be toggled per-message with /think and /no_think. Llama 3.2 has no equivalent default — it answers directly. On multi-step math, planning, and debugging prompts, this is why the default Qwen feels noticeably "smarter" on the first try, and it is a fairer explanation than raw parameter count alone.
Both defaults register a chat template with native tool-calling support, so an agent loop works out of the box on either. In our function-calling tests Qwen3 8B produced valid JSON tool calls more reliably, while Llama 3.2 3B occasionally malformed arguments on complex schemas — a size effect more than a family one. Neither ships a system prompt tuned for tools, so you still supply your own. If you plan to build agents, treat tool reliability as something to verify per model rather than assume from the default.
Cost of running the defaults
Local inference is not free — it is electricity plus amortized hardware. The table below estimates energy cost per one million generated tokens at $0.15/kWh, assuming ~250W of GPU draw under load. Numbers are rough and scale with your power price.
| Default model | tok/s | Load VRAM | Energy cost / 1M tokens* |
|---|---|---|---|
| Llama 3.2 3B | 138 | 3.5 GB | ~$0.08 |
| Qwen3 8B | 71 | 6.6 GB | ~$0.15 |
*$0.15/kWh, ~250W under load. Idle draw and hardware amortization excluded. The takeaway is that the higher-quality default costs roughly double per token to run, purely because it is slower and larger. For high-volume, low-complexity workloads (classification, extraction, autocomplete), the cheaper default Llama can be the rational choice even though it scores lower. Model our numbers against your own power price and throughput with the cost calculator.
Verdict: which default wins
If the question is strictly "you type one command, no tuning, which is better," Qwen3 8B wins the out-of-box crown. It is more accurate on knowledge, substantially better at code and math, ships reasoning on by default, and calls tools more reliably. The price is real — about half the speed and nearly double the VRAM and energy cost — but for a first-run experience where quality is what you judge, the default Qwen is the stronger showing.
Default Llama is not a loser; it is a different tool wearing the same convenience alias. Its 3B build is the right default when you are VRAM-starved, CPU-bound, latency-sensitive, or running at volume where per-token cost dominates.
| Use case / constraint | Default winner | Why |
|---|---|---|
| First run, no tuning | Qwen3 8B | Higher on every quality benchmark |
| ≤4GB VRAM / CPU-only | Llama 3.2 3B | Fits where Qwen won't |
| Coding & math | Qwen3 8B | +37 HumanEval, thinking mode on |
| Max tokens/sec | Llama 3.2 3B | ~2× throughput |
| Tool-calling agents | Qwen3 8B | More reliable JSON output |
| High-volume, low complexity | Llama 3.2 3B | ~½ the energy cost/token |
| Non-English tasks | Qwen3 8B | Broader multilingual coverage |
Bottom line: the honest fix for anyone comparing defaults is to stop comparing aliases and start comparing size classes. Pull qwen3 and llama3.1:8b if you want a true 8B-vs-8B read, or accept that the shipped defaults hand Qwen a structural advantage. For a zero-effort first run, that advantage makes Qwen the one to keep.
Frequently Asked Questions
What model does ollama run qwen3 actually download?
As of mid-2026 it resolves to Qwen3 8B (dense) at Q4_K_M quantization, a ~5.2GB download. Append a size tag such as qwen3:32b to change it.
Why is Qwen better than Llama out of the box if they're both "defaults"?
Mostly because the default aliases aren't size-matched: Ollama pulls an 8B Qwen but only a 3B Llama. Qwen3 also enables hybrid thinking mode by default, which lifts its math and reasoning scores.
Do both models default to a small context window?
Yes. Ollama caps context at 4096 tokens by default for both, even though Qwen3 8B supports 40,960 and Llama 3.2 supports up to 128k natively. Raise it with the num_ctx parameter.
Which default runs on a 6GB GPU?
Default Llama 3.2 3B fits comfortably at ~3.5GB. Default Qwen3 8B needs about 6.6GB at 4k context, so 6GB is too tight once you raise the context window — 8GB is the practical floor.
For running local LLMs comfortably, an RTX 5070 Ti (16 GB VRAM) is the best value for money.
Amazon Check RTX 5070 Ti price →As an Amazon Associate, BestLLMfor earns from qualifying purchases, at no extra cost to you. It does not influence our independent rankings.