On August 14, 2026, Alibaba quietly pushed the strongest open-weights coding model you can run on a single consumer GPU — and it does not require a 48 GB card to prove it.

Qwen 3.8-27B is the dense 27B sibling of the much larger Qwen3.8-Max MoE. It is Apache 2.0, it runs at 4-bit in 24 GB of VRAM, and on the official model card it lands 73.0 on Terminal Bench 2.1 — up from 63.4 on the Qwen3.6-27B it replaces. For a model that fits on a 4090, that is the number that matters.

What actually changed since Qwen3.6-27B

This is not a minor refresh. On the Qwen team's own model card, the jump is across the board:

Benchmark Qwen3.6-27B Qwen3.8-27B
Terminal Bench 2.1 63.4 73.0
SWE-bench Pro 53.5 61.7
DeepSWE 1.1 13.3 42.2
QwenSWEBench 49.3 79.0
LiveCodeBench v6 83.9 90.3

Two things stand out to me. First, Qwen 3.8-27B now beats Qwen3.7-Plus on coding (64.0 on TB2.1, 57.6 on SWE-bench Pro) — a dense 27B model overtaking the larger plus-tier model on agentic work is the kind of thing that used to be unheard of. Second, it still trails the best closed model on the list, Opus 4.6 Max at 78.2 on TB2.1, but the gap has closed to roughly five points. A year ago the gap on this size class was in the low twenties.

The DeepSWE jump (13.3 → 42.2) is the one I'd underweight, frankly. It is a huge relative move off a very low base, and 13.3 is the sort of number a model posts when it is not really handling the benchmark at all. I read 42.2 as "it now actually attempts these" rather than "it is now great at them."

The multimodal story is genuinely new

The 3.6 generation's vision was real but shallow. 3.8 is a native image-and-video model, and the computer-use numbers are the interesting part:

Benchmark Qwen3.6-27B Qwen3.8-27B
OSWorld-Verified 63.9 84.3
WebArena-Verified 48.8 64.8
AndroidWorld 70.3 81.9
OmniDocBench 1.5 89.4 91.1

An 84.3 on OSWorld-Verified puts a single-GPU model past every closed model on the Qwen's comparison table for computer use. Combined with hour-scale video understanding, this is the first time the "you can watch a screen and drive it" capability sits comfortably in the 24 GB class. If you have been waiting for a local model that could actually look at a UI and act on it, this is the one.

Running it locally

Unsloth's guide is the practical reference, and the memory math is the good news:

Quant Total memory (VRAM + RAM)
4-bit 17–19 GB
6-bit 24 GB
8-bit 31 GB
BF16 56 GB

Concretely: 4-bit runs on any 24 GB card (4090, 5080, or a 24 GB Mac), 6-bit and 8-bit fit a 5090's 32 GB, and BF16 needs two GPUs or a lot of RAM offload. On Blackwell specifically, the NVFP4 variant runs about 1.5× faster than BF16 at 24 GB — so if you have a 50-series card, that is the build to reach for.

A few runner notes worth knowing up front:

  • Hybrid thinking model. Thinking is on by default, with reasoning_effort levels of xhigh (default) / medium / low. For interactive use, drop it to low or medium — the default burns tokens on every turn.
  • Context. 262,144 tokens natively, extendable to 1M via YaRN. Do not plan on using the long end on 24 GB — the KV cache will eat your memory budget quickly.
  • Hybrid attention (Gated DeltaNet + Gated Attention). This is a new architectural mix, so verify your runner build actually supports it before you spend an evening debugging a "works for everyone else" error.

The catch

I want to be straight about what I have and have not verified:

  • These are self-reported benchmarks from Qwen's own model card, run on their harness (SWE-bench Pro and DeepSWE use the Claude Code harness at a 256K window). I have not independently reproduced any of them, and vendor-reported numbers on vendor-favored harnesses are the highest-risk kind of claim in this space. Treat the absolute numbers as directional until the community re-runs them.
  • Video and screen understanding is vision-understanding, not full multimodal parity. The OSWorld/WebArena wins are real, but closed frontier models still lead on the hardest video-reasoning work.
  • Thinking-on-by-default is a token tax. If you drop this into an agentic loop and leave the reasoning effort at xhigh, your token spend will surprise you.
  • 24 GB is the floor, not the comfort zone. 4-bit fits, but with 262K context and long agentic sessions you will want the headroom of a 32 GB card or system RAM to spill into.

Worth the switch?

If you already run Qwen3.6-27B, this is a near drop-in upgrade with real, not cosmetic, gains — the +9.6 on Terminal Bench 2.1 and the OSWorld jump are both things you will feel in a coding or UI-driven agent. If you are deciding what to put on a 24 GB card right now, it is the strongest open-weights answer in the dense 27B class, and the Apache 2.0 license means there is no fine-print surprise in it.

The pattern from May still holds: the gap between the best closed model and the best model you can run at home keeps shrinking, and now a 24 GB card can do computer use that the closed table has to answer for.

Sources

Related reading