Qwen3.8-27B on Ollama: One Command, Four Quants, and What "Free" Really Costs

Run it with one command: ollama run qwen3.8:27b. That is the whole answer to the question this page is about. Qwen3.8 27B — Ali​baba's dense 27-billion-parameter model, weights released August 14, 2026 under Apache 2.0 — went live in the Ollama library this week, and the default build is already a sensible 18 GB Q4_K_M quant (17 GB of weights plus a 931 MB vision encoder). It runs fully on a 24 GB GPU at normal context lengths, splits to CPU when your card is smaller, and costs nothing per token.

Everything here is dated August 15, 2026. Specs come from the Qwen3.8 27B model card; download sizes, tags and download counts come from the live Ollama library page; benchmark numbers are Ali​baba-reported and have no independent replication yet. The model shipped days ago, so treat anything that can change as provisional.

The one-liner that actually works

If you already have Ollama installed, you are two words away:

ollama run qwen3.8:27b

Ollama support landed in v0.32.12 — the release note reads, plainly, "This release adds the support of Qwe​n 3.8 27B." The first run downloads the default build (about 18 GB, Q4_K_M), then drops you into a chat REPL with thinking mode on by default. The library page lists the build with the capability tags "vision tools thinking 27b", which is how you know the vision and tool-calling paths are wired into the same download. As of this writing the page shows more than 40,000 downloads and a tag list that already spans eleven variants.

Two variants you will actually reach for:

• ollama run qwen3.8:27b-mlx — the Apple Silicon build, same 18 GB footprint but compiled for Metal; it is the one Ollama's release note specifically optimizes "for maximum performance and output quality suitable for repeated tasks and coding agents."

• ollama run qwen3.8:27b-q8_0 — a 30 GB 8-bit quant, for when you have the VRAM and want the weights closer to full precision.

What you are actually downloading

The name says 27B, but the full parameter count is 28B: a 27.3B dense language model plus a 461M vision encoder that gives it native image and video input. The rest of the headline spec, straight from the model card:

• 64 layers, hidden size 5,120, vocabulary 248,320.

• Hybrid attention: 16 full Gated Attention layers and 48 linear Gated DeltaNet layers — a 3:1 lean-linear mix, and the reason a 27B can keep a 262,144-token native context (extendable to 1M) without the KV cache consuming a whole datacenter.

• Native image and video understanding — "from STEM diagrams and documents to hour-scale videos" is Ali​baba's phrasing.

• Apache 2.0. Download it, modify it, sell a product on it. That license is the legal fact the rest of this article's economics hang on.

The full-precision reference is BF16, which is why the 56 GB tags exist; every smaller tag is a trade of precision for footprint, and the model card's own benchmarks are what you are trading against.

Pick a quant, then check your VRAM, not the other way around

Ollama gives you eleven tags, but the decision collapses to three sizes.

• 18 GB — Q4_K_M (default). Fits fully on a 24 GB card (RTX 4090 / 5090 class) at normal context, and on 16 GB cards with partial CPU offload — slower, but it works. This is the build for "just run it."

• 30 GB — Q8_0. Weights near full precision, needs roughly 40 GB of VRAM to stay fully on-GPU. On a 27B, you should already know why you want the extra fidelity before paying for it.

• 56 GB — BF16. The reference build. Requires H100-class or 96 GB hardware. Nobody is running this on a consumer GPU, and that is fine.

The number that trips people up is the KV cache. The 18 GB download does not mean 18 GB of VRAM is enough for a 262K-context session — at long context the cache adds several gigabytes on top of the weights, which is why a 24 GB card will hold this model comfortably at 8K–32K context but not at 262K. On a borderline card, drop the context, not the quant.

Apple Silicon is a first-class target here

Ollama's v0.32.12 release note calls out macOS specifically. Concretely, ollama run qwen3.8:27b-mlx needs about 18 GB of unified memory, so a 24 GB+ Mac runs it fully on the GPU with headroom for context. There is also a 32 GB mxfp8 MLX tag and a 56 GB mlx-bf16 tag for the 64–128 GB machines. If your M-series Mac has been watching the desktop-model news, this is the build you have been waiting for.

Context: 262K on the spec sheet, less in your seat

The model card lists 262,144 native tokens, extendable to 1M; Ollama's library page reports the same window as 256K. Both are true — 262,144 is 256K times 1024 — and neither means you should type that number into --num-ctx on a 24 GB card. The KV cache grows roughly linearly with context, so on consumer hardware you will live at 16K–64K, not 262K. Start with the Ollama default, raise --num-ctx only when a task actually needs it, and remember the 1M figure requires the extension machinery plus the VRAM to feed it.

What is still shaky — read this before you bet on it

• No independent benchmarks yet. Every figure on the model card is Ali​baba's word as of August 15. The claimed gains over Qwen3.6-27B are large — SWE-bench Pro 61.7 vs 53.5, Terminal Bench 2.1 73.0 vs 63.4, LiveCodeBench v6 90.3 vs 83.9, GPQA Diamond 89.2 vs 87.8 — and they all read as plausible, and none of them has been reproduced by an outside harness. Do not rest a production decision on them alone.

• The vision stack is days old. An early bug report (ollama issue #17753) showed the Q4 build routing vision input through the Qwen3.5 parser and failing on images; it was fixed within days in PR #17755, but the multimodal path on a week-old model is exactly where you should test before relying on it.

• The default build includes MTP. The q4_K_M tag is also the multi-token-prediction build — faster decoding, and the reason "18 GB" and "27B" can coexist without contradiction.

• Quant labels can mislead on Apple. The 18 GB "mlx" and "nvfp4" tags differ in quantization — NVFP4 is an NVIDIA FP4 format — so on a Mac prefer the plain -mlx build unless you specifically need an FP8/FP4 variant for a Blackwell GPU.

"Free" is doing a lot of work in that headline

Self-hosting a 27B is free per token, but it is not free. The honest framing is three options that cost different currencies:

• Run it yourself (Ollama). $0 per token, offline, unlimited, private — and the hardware is yours. A 24 GB GPU or an 18 GB+ Mac is a real purchase, and so are the electricity and the setup time. This is the right call when Qwen3.8 27B becomes a daily driver.

• Call a $0 rate-limited API. OrcaRouter serves Qwen3.8 27B on its own infrastructure at zero cost (model ID qwen/qwen3.8-27b-free, $0 per request, rate-limited) — because the weights are open, there is no per-token vendor cost to pass through. This is the right call when you want to try the model without buying hardware to test a week-old release.

• Call an unlimited API. The same model without the rate limit is $0.33 per million input tokens and $2.40 per million output on OrcaRouter (qwen/qwen3.8-27b, 262K context, text, image and video input). This is the right call when you need production scale and do not want to babysit a GPU.

The math that decides between them: occasional use pays for itself better at $0 or at $0.33/$2.40 than at the price of a GPU; daily interactive use is cheaper locally; sustained production throughput is cheapest as an API you do not have to keep alive. Privacy and offline requirements move you to the first column no matter what the math says.

When this recommendation is wrong

• You genuinely need 100K+ context. The model can do it; your 24 GB card cannot. At real long-context, a 40 GB+ GPU or a longer-context API is not a luxury.

• You need video in production today. The vision path just had its parser bug fixed; production video on a week-old multimodal model is a bet you should not place without a fallback.

• You want concurrency. One consumer GPU streams one or two generations at a time. A 27B is not a serving box.

• You are on CPU-only hardware. A 27B at 4-bit on CPU is a slow demonstration, not a tool. An API is the honest choice until you have a GPU.

The bottom line

Qwen3.8 27B on Ollama is the easiest way to run a current-generation 27B that anyone has shipped yet: one command, an 18 GB default that fits a 24 GB card, a first-class Apple Silicon build, and Apache 2.0 freedom. The quant you should pick is almost always the default Q4_K_M — move to q8_0 only when you can measure the difference. And the "free" is conditional: if you will touch the model occasionally, the $0 rate-limited API is freer than buying hardware; if it becomes your daily driver, the local copy is the cheapest thing you own. Verify the numbers before you build on them — everything in this article was true on August 15, 2026, and this model is changing by the day.