The best Ollama models for everyday use (2026 guide)

2026 guide to choosing Ollama models: comparison table of Qwen 3.5, Gemma 4, gpt-oss, qwen3-coder and more, with quantization, required RAM, and what to install based on your hardware.

The comparison table
How to read this table without getting it wrong
What makes a model "efficient" in 2026
The models, one by one
What to install based on your hardware
Quantization, in two minutes
Common mistakes that ruin the experience
A recommended stack to start today
Frequently asked questions
What actually changed

The comparison table

Model (tag)	Download size	Context	Recommended RAM	Multimodal	Tools / reasoning	Best for
`qwen3.5:2b`	2.7 GB	256K	8 GB	Text + image	Yes / Yes	The minimum all-rounder. Summaries, rewriting, classification
`llama3.2:3b`	2.0 GB	128K	8 GB	Text only	Yes / No	Instant answers, autocomplete, simple tasks on CPU
`qwen3.5:4b`	3.4 GB	256K	8–12 GB	Text + image	Yes / Yes	The best starting point for most people
`gemma4:e2b-it-qat`	4.3 GB	128K	8–12 GB	Text + image	Yes / Yes	Writing and a natural tone on modest hardware
`qwen3.5:9b`	6.6 GB	256K	16 GB	Text + image	Yes / Yes	The best quality/size balance in the whole list
`gemma4:12b`	7.6 GB	256K	16 GB	Text + image	Yes / Yes	Long-form writing, document analysis, multilingual
`gpt-oss:20b`	14 GB	128K	16–24 GB	Text only	Yes / Yes (adjustable)	Explicit reasoning and agentic workflows
`qwen3-coder:30b`	19 GB	256K	24 GB	Text only	Yes / No	Repo-scale coding (MoE, 3.3B active)
`qwen3.5:27b`	17 GB	256K	24 GB	Text + image	Yes / Yes	"Serious assistant"-level quality without the cloud
`qwen3.6:35b`	24 GB	256K	32 GB+	Text + image	Yes / Yes	The best you can run on high-end consumer hardware
`gemma4:31b-it-qat`	19 GB	256K	24–32 GB	Text + image	Yes / Yes	A Qwen alternative with a different license and tone
`glm-ocr`	2.2 GB	128K	8 GB	Image → text	Yes / No	OCR for invoices, tables, and scanned documents
`embeddinggemma:300m`	622 MB	2K	8 GB	Embeddings	—	Semantic search and RAG over your files
`nomic-embed-text`	274 MB	8K	8 GB	Embeddings	—	The classic RAG workhorse, fast and proven

The "Recommended RAM" column is not the file size: it includes the space needed for the active context plus headroom so your operating system can keep breathing. More on that in a moment.

How to read this table without getting it wrong

There are three numbers people constantly confuse, and confusing them is the number-one reason someone downloads a model and concludes that "local models are garbage."

Download size is not the RAM it consumes. A 6.6 GB model takes up those 6.6 GB in memory plus the attention cache (KV cache), which grows with the length of the conversation. A reasonable working rule: add 20–30% to the file size for normal use, and keep at least 2 GB free for the system. If you're going to use very long contexts, the margin needs to be bigger.

Parameter count no longer predicts speed. A qwen3-coder:30b has 30 billion total parameters but only activates 3.3 billion per token, because it's a mixture of experts (MoE) architecture. It generates text at the speed of a small model and responds with the judgment of a large one. You pay the price in RAM, not in waiting time. The same applies to qwen3.5:35b-a3b and gemma4:26b-a4b.

The advertised context window isn't free. Just because a model supports 256K tokens doesn't mean you can use 256K on your laptop. That context materializes in memory. In practice, on a 16 GB machine you'll work comfortably between 8K and 32K tokens, which is more than enough for almost any everyday task.

What makes a model "efficient" in 2026

It's worth understanding why the list above looks so different from the one two years ago.

The biggest change is quantization-aware training (QAT). Instead of training a model at full precision and then compressing it — losing quality in the process — labs now train the model knowing it will run in 4 bits. Google publishes -it-qat variants of Gemma 4 that weigh substantially less than traditional Q4 versions: gemma4:e4b-it-qat takes 6.1 GB versus the 9.6 GB of the standard version, with far less degradation than you'd expect. If you're going to use Gemma 4, always start with the QAT tag.

The second change is MXFP4, the format OpenAI uses in gpt-oss. The MoE weights are quantized to 4.25 bits per parameter from post-training, and Ollama runs them natively without additional conversions. It's the reason a 20B model fits in 14 GB and works on a 16 GB machine.

The third is the proliferation of intermediate sizes. Qwen 3.5 ships in 0.8B, 2B, 4B, 9B, 27B, 35B, and 122B. That granularity matters: instead of choosing between "too dumb" and "doesn't fit," you can find the exact step for your hardware.

And the fourth, on Mac: the MLX and nvfp4 tags. If you have Apple Silicon, the -mlx variants are compiled for Apple's engine and typically give you better performance per watt than generic GGUFs. qwen3.5:9b-mlx (8.9 GB) is an excellent choice on a MacBook with 16 GB of unified memory.

The models, one by one

Qwen 3.5 — the family you should install first

If you're only going to read one paragraph of this guide, make it this one. The Qwen 3.5 family covers 0.8B up to 122B, all with 256K native context and all with text and image input. It's multimodal, supports tool calling, and has a reasoning mode. In practice, it's the model that handles 80% of what people ask of a local assistant.

ollama pull qwen3.5:4b     # 3.4 GB — the entry point
ollama pull qwen3.5:9b     # 6.6 GB — the sweet spot
ollama pull qwen3.5:27b    # 17 GB  — if your GPU can handle it

The 9b is probably the best quality-to-size ratio in the entire catalog right now. It fits in 16 GB with room to work, understands images, and the difference versus the 27b on everyday tasks — drafting, summarizing, translating, explaining — is noticeably smaller than the weight difference would suggest.

When not to use it: if your main task is agentic coding over a large repository, qwen3-coder:30b is specifically trained for that.

Gemma 4 — Google's alternative, with audio

Gemma 4 is Google's answer, and it brings something Qwen doesn't have: audio input, in addition to vision, tools, and reasoning. Sizes run from e2b to 31b, where the "e" variants are effective-parameter models — designed so the real computational cost is lower than the nominal one.

ollama pull gemma4:e2b-it-qat   # 4.3 GB
ollama pull gemma4:12b          # 7.6 GB, 256K context
ollama pull gemma4:31b-it-qat   # 19 GB

The gemma4:12b deserves special attention: 7.6 GB for 256K of context is an excellent density, and Gemma tends to write in a more natural, less "textbook" register than other families. For emails, articles, and text that a human will actually read, many people prefer it.

When not to use it: on math reasoning or coding tasks, Qwen and gpt-oss usually pull ahead.

gpt-oss:20b — reasoning with adjustable effort

OpenAI's open-weight models arrived with two features that set them apart: a full, visible chain of thought, and configurable reasoning effort at three levels (low, medium, high). You can ask it to think little when you want speed, and a lot when the problem justifies it.

ollama pull gpt-oss:20b   # 14 GB, 128K context

Apache 2.0 license, no copyleft restrictions, suitable for commercial use. It's the default choice if your use case involves agents, function calls, structured outputs, or reasoning debugging — because you can read exactly how it reached its conclusion.

When not to use it: it doesn't process images. If you need multimodality, go back to Qwen or Gemma.

qwen3-coder:30b — the code specialist

30B total, 3.3B active, 256K native context (extrapolatable to 1M). Trained on 7.5 trillion tokens with a 70% code proportion, and with reinforcement learning aimed at actual code execution. It's designed for repo-scale engineering tasks, not for autocompleting loose lines.

ollama pull qwen3-coder:30b   # 19 GB
ollama launch opencode --model qwen3-coder

On a 24 GB GPU it's the best local coding option available today. Being MoE, it generates at the speed of a small model despite its size.

When not to use it: for general questions it's a waste of RAM. Keep a general-purpose model loaded in parallel.

Qwen 3.6 — the next step up

The most recent Qwen generation, available in 27b (17 GB) and 35b (24 GB). Its improvements focus on agentic coding — frontend workflows and repo-level reasoning — and on reasoning preservation, an option that retains the thought context of previous messages so it doesn't repeat work in iterative conversations.

ollama pull qwen3.6:27b

If you have 32 GB or more and want the best that consumer hardware can run, this is it. If you have 16 GB, stick with qwen3.5:9b and don't suffer.

Llama 3.2 (1B and 3B) — the featherweight

Llama 3.2 isn't the newest anymore, but it stays relevant for one concrete reason: 1.3 GB and 2.0 GB with tool support and 128K context. It's the model you leave permanently loaded on a modest machine or a small server, the one that responds in under a second, the one that runs well even without a GPU.

ollama pull llama3.2:3b   # 2.0 GB
ollama pull llama3.2:1b   # 1.3 GB

For rewriting a paragraph, classifying text, extracting entities, or generating a short response, it's perfectly adequate. For reasoning through a problem, it isn't.

glm-ocr — the specialist almost nobody knows

Just 0.9B parameters, 2.2 GB download, and it does one thing extraordinarily well: turning documents into structured text. Complex tables, formulas, stamps, code-heavy documents, difficult layouts. It has specific modes you invoke right in the prompt:

ollama run glm-ocr Text Recognition: ./factura.png
ollama run glm-ocr Table Recognition: ./reporte.png
ollama run glm-ocr Figure Recognition: ./diagrama.png

If you regularly digitize invoices, receipts, or scanned documents, this model alone justifies having Ollama installed.

Embedding models — invisible but necessary

If you want to search across your own documents — "where did I mention the March budget?" — you need an embedding model, not a chatbot. They're tiny and do a different job: turning text into vectors so you can compare it by meaning.

ollama pull embeddinggemma:300m      # 622 MB, from Google
ollama pull nomic-embed-text         # 274 MB, the de facto standard
ollama pull qwen3-embedding:0.6b     # if you already use the Qwen family

Mind the context window here: embeddinggemma accepts 2K tokens and nomic-embed-text reaches 8K. That determines how to chunk your documents — fragments of 500 to 1000 tokens work well with either.

For Spanish or multilingual content, nomic-embed-text-v2-moe and snowflake-arctic-embed2 are specifically trained for multilingual retrieval and usually deliver better results than English-only versions.

What to install based on your hardware

8 GB of RAM (no dedicated GPU, or a small one)

This is the most common scenario and the most misunderstood. It does work, but you have to be disciplined: one model loaded at a time, Q4 quantization, moderate context.

ollama pull qwen3.5:4b       # 3.4 GB — your main model
ollama pull llama3.2:3b      # 2.0 GB — for instant answers
ollama pull glm-ocr          # 2.2 GB — documents and images
ollama pull nomic-embed-text # embeddings for local search

The golden rule at 8 GB: a small model in Q4 always beats a large model in Q2. The temptation to force a 14B compressed to the extreme ends in incoherent answers. Don't do it.

16 GB of RAM

This is where the experience starts to feel genuinely comfortable. You can run a 9–12B model with wide context, or keep two small models loaded simultaneously to compare them.

ollama pull qwen3.5:9b       # 6.6 GB — your workhorse
ollama pull gemma4:12b       # 7.6 GB — for long-form writing
ollama pull gpt-oss:20b      # 14 GB — for reasoning (one at a time)
ollama pull embeddinggemma:300m

With 16 GB you can also afford to step up to Q5 or Q8 quantization on small models, which recovers some reasoning fidelity in exchange for little speed.

24 GB of VRAM (RTX 4090 / 5090 or similar)

The range where local models stop feeling like a compromise.

ollama pull qwen3.5:27b      # 17 GB — serious general assistant
ollama pull qwen3-coder:30b  # 19 GB — coding
ollama pull gemma4:31b-it-qat # 19 GB — multimodal alternative

32 GB or more (including unified memory on Mac)

ollama pull qwen3.6:35b      # 24 GB — the practical ceiling of consumer hardware
ollama pull qwen3.5:35b-a3b  # 24 GB — MoE, faster than its size suggests

On Apple Silicon, try the MLX tags first: qwen3.6:35b-mlx (22 GB) and qwen3.5:27b-mlx (20 GB) are optimized for Apple hardware.

Quantization, in two minutes

Quantization reduces the precision of the model's weights so it takes up less memory. It's the most important lever you have, and it's where most people get it wrong.

Q4_K_M is the standard. It cuts consumption by around 70% versus full precision with a quality loss that's hard to perceive on everyday tasks. When in doubt, pick this. On 8 GB machines, it's not an option: it's the only sensible one.

Q8_0 roughly doubles the size versus Q4 and recovers fidelity in reasoning and math. It makes sense on small models when you have memory to spare — qwen3.5:4b-q8_0 weighs 5.3 GB and is noticeably more solid than the Q4 version on logic tasks.

QAT (Gemma's -it-qat tags) is trained quantization, not compressed after the fact. When it exists, prefer it over the equivalent Q4.

MXFP4 is gpt-oss's native format. You don't have to choose anything: the model already comes this way.

MLX / nvfp4 are variants for Apple Silicon and for NVIDIA GPUs with FP4 support. If your hardware qualifies, they deliver better performance with the same or lower consumption.

The practical decision hierarchy is simple: first choose the model size that fits in your memory at Q4, and only then consider bumping the quantization if you have room to spare. Never the other way around.

Common mistakes that ruin the experience

Setting context to the maximum "just in case." Configuring 256K of context on a 16 GB machine fills memory with empty cache and leaves you no room for the model. Start at 8K and only go up if you need to.

Judging a model by the first response. The first generation includes the time to load the model into memory. The second one is what represents the real speed.

Using a chat model for semantic search. They're different tools. If you want to search your documents, you need an embedding model plus a vector database, not a chatbot with the document pasted into the prompt.

Ignoring specific tags. ollama pull gemma4 brings you latest, which is e4b at 9.6 GB. gemma4:e4b-it-qat does practically the same thing in 6.1 GB. It's worth scanning the tag list before downloading.

Not cleaning up old models. Every experiment leaves gigabytes on disk. ollama list shows you what you have and ollama rm <model> deletes it.

A recommended stack to start today

If you want a setup that works well from day one without overthinking it, on a 16 GB machine:

# Main model: conversation, summaries, drafting, images
ollama pull qwen3.5:9b

# Fast answers and simple tasks
ollama pull llama3.2:3b

# Scanned documents, invoices, tables
ollama pull glm-ocr

# Semantic search across your files
ollama pull embeddinggemma:300m

That's about 10 GB on disk and it covers virtually everything a person does with an assistant: write, summarize, translate, explain, read documents, and find things. When one of those tasks falls short, you'll already know exactly which model to add and why.

Frequently asked questions

How much RAM do I need to run Ollama?

As a practical minimum, 8 GB with a 4B model in Q4 quantization and moderate context. For a comfortable, no-compromise experience, 16 GB lets you run 9–12B models. For serious coding use or a high-quality general assistant, aim for 24 GB of VRAM. Remember to add 20–30% on top of the model size for context and keep 2 GB free for the system.

What's the best Ollama model for a 16 GB laptop?

qwen3.5:9b (6.6 GB). It's multimodal, has 256K of context, supports tools and reasoning, and leaves enough free memory to work with. It's the best quality-to-size ratio in the catalog right now.

Is Ollama free?

Yes. Ollama is free software and the models this guide recommends have permissive licenses (Apache 2.0, Apache 2.0 derivatives, and similar ones suitable for commercial use). The only thing you pay for is electricity and hardware.

Can I use Ollama without an internet connection?

Yes. Once the model is downloaded with ollama pull, all processing happens locally. Nothing is sent to the cloud, which makes it ideal for sensitive data, contracts, invoices, or offline work.

What's the difference between a chat model and an embedding model?

A chat model (like qwen3.5:9b) generates text from an instruction. An embedding model (like nomic-embed-text or embeddinggemma:300m) turns text into numeric vectors to compare documents by meaning. If you want to search "where did I talk about the March budget?" across your files, you need embeddings, not a chatbot.

What actually changed

Two years ago, running a model locally meant accepting a clearly inferior assistant in exchange for privacy. Today the equation is different: for everyday tasks — drafting, summarizing, rewriting, classifying, extracting, translating — a 6.6 GB qwen3.5:9b does a job that most people wouldn't distinguish from a cloud service.

The gap still exists, but it has shifted upward: it's in deep reasoning, in very complex coding tasks, and in highly up-to-date world knowledge. Everything else already fits on your laptop, works offline, and tells nobody anything.

All sizes, tags, and context windows cited come from the official Ollama catalog, consulted in August 2026. Models update frequently: verify the current tags on ollama.com before downloading.