Qwen 3.8-27B Review: Benchmarks, Community Verdict and Hardware Reality

On August 14, Alibaba released Qwen 3.8-27B as open weights under the Apache 2.0 license. In a 4-bit quant it takes about 17 GB, and vision comes included. Even on a laptop, away from any GPU rack, the model can be pulled down and served through llama.cpp, and the result is better than "impressive for its size." It deliberates longer than other local models, catches edge cases that an earlier daily driver missed, and returns work that once called for a paid frontier API.

Three questions get answered below. How does it fare against Opus 4.6, GLM 5.2 and DeepSeek V4 Flash 0731? What did users say after a fortnight of real use? And what does it take, hardware-wise, that no benchmark table admits?

What you actually get

Qwen 3.8-27B is a dense model with 27 billion parameters, all of them active on every token. It isn't a sparse mixture-of-experts dressed up as a small model. The interesting part is attention. Most layers use a cheap linear mechanism (Gated DeltaNet), and only every fourth layer applies full attention. That three-to-one mix is how it ships with a native 262K-token context without devouring memory, and Qwen says the window can be stretched to 1M tokens.

It also handles images and video. Most important, it thinks by default. The top reasoning level ("xhigh") is enabled out of the box, so every prompt triggers a lengthy internal debate before an answer appears. That thinking mode decides whether the model feels great or frustrating, and it comes up again below.

Comparisons

Versus Opus 4.6: stronger at the work, weaker at the exams

Here's the scoreboard from each vendor's own published numbers:

| Benchmark          | Qwen3.8-27B | Opus 4.6 Max | GLM-5.2   |
|--------------------|-------------|--------------|-----------|
| SWE-bench Pro      | 61.7        | 53.4         | 62.1      |
| Terminal-Bench 2.1 | 73.0*       | 78.2         | 81.0*     |
| GPQA Diamond       | 89.2        | 91.3         | 91.2      |
| HLE                | 30.8        | 40.0         | 40.5      |

These come from different test harnesses per vendor, so treat them as directional.

In plain English, Qwen wins where agents do real work. SWE-bench Pro means fixing genuine bugs in real repositories, and Qwen leads Opus there by more than 8 points. It also wins instruction following (IFBench 79.5 against 62.5) and everything visual: the OSWorld computer-use score rose from 63.9 for the old Qwen to 84.3, beating Opus at 72.7.

The areas where Opus keeps its lead are the toughest reasoning sets: GPQA, which asks graduate-level science questions, and HLE, nicknamed "Humanity's Last Exam". Those sit in frontier-math territory, and a file of 17 GB can't reach them yet.

A warning before quoting the table anywhere: every figure comes from the vendor's own card and harness. Alibaba ran SWE-bench Pro with the Claude Code harness and graded HLE using GPT-4o. Read it as a ceiling and not a floor, though it's still the best map available.

Versus DeepSeek V4 Flash 0731: equal score, a fraction of the hardware

DeepSeek V4 Flash is a 284-billion-parameter MoE with 13B active per token. On the independent Artificial Analysis index, where every model faces the same nine evaluations, Qwen 3.8-27B scores 52, exactly the same as DeepSeek V4 Flash 0731.

Same score, different needs. One runs on a single 24 GB card and understands images. The other wants five RTX 3090s, and its prefill is painfully slow by comparison.

Versus GLM 5.2: close, with a footnote

Zhipu's GLM-5.2 is MIT-licensed with a solid 1M context, and it's the nearest rival on paper: 62.1 against Qwen's 61.7 on SWE-bench Pro, and 81 against 73 on Terminal-Bench using their harness. Qwen gets the nod for two reasons: it includes vision, and it fits on a card people already own.

The footnote is that Zhipu released GLM-5.3 on August 18, two days after Qwen. It scores 60 on the same index where Qwen has 52, so that contest is already being replayed.

Community reactions

After two weeks, r/LocalLLaMA had hundreds of threads and Hacker News held a 375-point discussion. Opinion falls into three camps, plus one more.

Camp one: frontier intelligence at home. That phrase is an actual Hacker News comment. A user with a 5090 told the release megathread that over 80% of his work no longer needs Claude. One long community review called it Sonnet-level, with room to reach Opus-level results. Simon Willison, a professional LLM reviewer, called it excellent and drove his own coding agent with it, marveling that a 17 GB file can do all this.

One outside result stands out. Harvey's legal-agent benchmark simulates a law firm with more than 100M tokens spread over roughly 10,000 documents. An adapted Qwen3.8-27B outscored Claude Opus 4.8 there, at about $0.13 per query versus $1.32. Treat it with care: the adapted model had studied that firm's corpus beforehand, which shows the power of domain tuning on a 27B model and says little about the stock weights. Even so, it's a first hint that the ability carries beyond Alibaba's own test setups.

Camp two complains about the overthinking tax. With xhigh on by default, a task that takes two and a half minutes without thinking can stretch to 21 minutes. Simon Willison's pelican test shows it: he asked for a simple SVG pelican, and the model used over 22,000 reasoning tokens for 3,200 tokens of final output. The drawing turned out well, but it cost him 21 minutes. Across tasks the model emits about twice as many tokens as Qwen 3.6-27B, and on consumer hardware that translates into waiting.

Camp three: it hallucinates outside code. This one stings because it's accurate. Its world-knowledge score (AA-Omniscience) slipped slightly below Qwen 3.6, a trade of recall for capability. Users describe confident wrong answers about general facts, and one had it loop for over an hour on a CLI task that a web search would have solved.

Then there are the people who sped it up, who matter most. Within a few days, the community had NVFP4 quants working together with MTP speculative decoding, and a single RTX 5090 hit 200+ tokens per second with the whole 262K context loaded. Slowness is tunable, so if it feels sluggish, suspect the setup before the model.

First impressions: it sits with the problem

Compared with Qwen 3.6-27B, the standout change after a week of daily use is persistence. Qwen 3.6 was fast, competent and slightly lazy, giving answers that covered the happy path and stopped. Qwen 3.8 weighs edge cases nobody mentioned: an empty input, an API returning a 500 on the second call, a file that no longer exists by step four. Output comes back more complete, and "close enough" answers nearly vanished.

Users also worked out how to steer it. A popular trick is to inject a line such as "you have 12K tokens of thinking budget per turn" into the model's reasoning, then repeat reminders when half and three quarters of the budget are gone. That turns xhigh from a fixed tax into an adjustable dial. Inside an agent harness, either control the effort level or hand it a budget. Once told to wrap up its thinking, the model is concise enough, but it never offers to do so unprompted.

Where to run it

A surprise on Apple Silicon: with llama.cpp on an M4 Max MacBook Pro, turning on MTP slowed inference down instead of speeding it up. Willison measured about a 72% gain from MTP speculative decoding, but that was on the CUDA path. On a Mac, run it plain and accept the pace.

The architecture hasn't changed the math. It's still a 27B dense model, so what applies to this class of model applies here. A practical map:

• RTX 3090 or 4090 (24 GB): Q4 fits comfortably, and Q8 works across two GPUs. Daily use starts to feel real, and community reports of 40 to 70 tok/s with MTP on CUDA match expectations for this card class.
• RTX 5090 (32 GB): the sweet spot at the moment. NVFP4 plus MTP pushes past 200 tok/s for a single stream with full context. For one card dedicated to local AI in 2026, this is it.
• DGX Spark or MacBook Pro: it runs and it's fun to watch, but it's still too slow for everyday work. Think of it as the travel model.

No magic here. If a laptop is your only machine and you need frontier-level thinking daily, the honest advice is to rent a GPU or wait a chip generation. The intelligence fits in your bag. The patience doesn't.

The path to this model

Opus 4.6 in early 2026 was the jolt that made a self-hosted agent feel worth building: if a subscription could do that, the same capability should run on owned hardware. Qwen 3.5-27B made such an agent work locally, and Qwen 3.6-27B then took over and still covers about 90% of daily work. Edge cases kept slipping through, though, the kind where a faster, shallower model gives up or guesses.

That gap pulled things toward DeepSeek V4 Flash 0731, which greatly improved agent intelligence and was the first local model that seemed to reason about a codebase and not just pattern-match it. It needs all five RTX 3090s, though, and its prefill is so slow that long sessions drag.

Then Qwen 3.8-27B arrived, and the numbers finally worked: DeepSeek V4 Flash-level intelligence on one card, with vision. Each model did one job. Opus showed what was possible, DeepSeek showed how well an agent could think, and Qwen 3.8 is the first that can stay on a desk without a power bill.

What comes next

The trend is obvious now: local AI is no longer a toy or an add-on, and it's advancing on two fronts at once. Small models improve faster than anyone predicted. This one jumped from a plain 27B to Sonnet-class results in an agent harness within one generation, and 200 tok/s on a single card appeared within days of launch. Hardware is closing in too. on day one AMD benchmarked the same model on its Ryzen AI Max+ laptop processor and got 24.5 tokens per second, so RTX 3090-class performance is heading toward mobile devices.

Combine the two and the forecast isn't wild: DeepSeek V4 Flash-level intelligence in your pocket, on a chip small enough for a phone.

Where to read more

The official model card covers specs and licensing, and Simon Willison's review is the best hands-on account of the thinking-mode trade-offs. Artificial Analysis publishes the independent index scores, and Zhipu documents GLM-5.2 and GLM-5.3 on its own blog.