Alibaba's Qwen team just dropped Qwen3.8-27B, and it's easily one of the most interesting open-weight releases of the year. It's a dense 27B-parameter model that natively understands images and video, ships with flexible "thinking" control, and posts benchmark numbers that put it in the same conversation as much bigger closed models on agentic and coding tasks.
In this post I'll walk through what Qwen3.8-27B actually is, how it's built, how it stacks up against its own predecessors and a couple of other models, and how you'd actually run it.
What Is Qwen3.8-27B?
Qwen3.8-27B is the compact, deployment-friendly member of the new Qwen3.8 generation, which builds on the architecture Qwen introduced in Qwen3.5. It's a causal language model with a vision encoder — meaning it's not a bolted-on multimodal adapter, but a model natively trained to reason over text, images, and even hour-long videos.
The headline features:
- Coding, agentic, and research-focused improvements over Qwen3.5/3.6/3.7
- Stronger agent execution — better autonomous planning and recovery from environment feedback for long-horizon tasks
-
Flexible thinking control — reasoning is on by default but can be toggled off, and reasoning depth is tunable via a
reasoning_effortparameter (xhigh,medium,low) - Native vision-language understanding — from STEM diagrams and dense documents to hour-scale video
- Massive context — 262,144 tokens natively, extensible to 1,000,000 tokens via YaRN scaling
It's released under the Apache 2.0 license on Hugging Face, so it's fully open for commercial use.
Architecture Snapshot
Under the hood, Qwen3.8-27B is a fairly unusual hybrid architecture rather than a plain transformer stack:
| Spec | Value |
|---|---|
| Parameters | 27B (28B including padding overhead) |
| Hidden dimension | 5,120 |
| Layers | 64 |
| Layer pattern | 16 × (3 × (Gated DeltaNet → FFN) → 1 × (Gated Attention → FFN)) |
| Gated DeltaNet heads | 48 (V), 16 (QK), head dim 128 |
| Gated Attention heads | 24 (Q), 4 (KV), head dim 256, RoPE dim 64 |
| FFN intermediate dim | 17,408 |
| Vocabulary | 248,320 tokens |
| Multi-Token Prediction | Trained with multiple steps |
| Native context | 262,144 tokens (up to 1M with YaRN) |
The interesting bit is the hybrid linear-attention/full-attention layout: most layers use Gated DeltaNet (a linear-attention variant), with a full Gated Attention block inserted every fourth sub-block. This is a common pattern in recent efficient-LLM design — it keeps compute and KV-cache costs down for long-context workloads while still preserving the precise, global attention that harder reasoning tasks need.
Benchmark Comparison
Qwen published benchmarks against three other models: its own predecessors Qwen3.6-27B and Qwen3.7-Plus, a third-party model called Muse Glimmer-30B, and a much larger closed model, Opus4.6 Max, used as a frontier reference point.
Coding and Agentic Tasks (Text)
| Benchmark | Qwen3.8-27B | Qwen3.6-27B | Qwen3.7-Plus | Muse Glimmer-30B | Opus4.6 Max |
|---|---|---|---|---|---|
| Terminal-Bench 2.1 (agentic terminal coding) | 73.0 | 63.4 | 64.0 | 51.7 | 78.2 |
| SWE-bench Pro (agentic coding) | 61.7 | 53.5 | 57.6 | 51.2 | 53.4 |
| NL2Repo-Bench (repo-level codegen) | 42.3 | 36.2 | 41.1 | — | 47.6 |
| DeepSWE 1.1 | 42.2 | 13.3 | 14.2 | — | — |
| QwenSWEBench | 79.0 | 49.3 | 59.2 | — | 63.8 |
| CoWorkBench (long-horizon office work) | 70.7 | 61.0 | 65.1 | — | 68.2 |
| JobBench (professional tasks) | 33.4 | 21.8 | 27.6 | — | — |
| Agents' Last Exam (Pass@1 / Score) | 20.4 / 42.9 | 10.6 / 27.3 | 13.2 / 33.6 | — | — |
| IFBench (instruction following) | 79.5 | 69.1 | 79.1 | 77.0 | 62.5 |
| GPQA Diamond (scientific reasoning) | 89.2 | 87.8 | 90.3 | 83.5 | 91.3 |
| HLE (multidisciplinary reasoning) | 30.8 | 24.0 | 34.7 | 22.0 | 40.0 |
| LiveCodeBench v6 | 90.3 | 83.9 | 89.6 | — | 88.8 |
A few things jump out:
- The generational jump from Qwen3.6 to Qwen3.8 is large. On DeepSWE 1.1, Qwen3.8-27B more than triples Qwen3.6-27B's score (42.2 vs 13.3). On QwenSWEBench it jumps nearly 30 points.
- Qwen3.8-27B beats Opus4.6 Max on several agentic and coding benchmarks — SWE-bench Pro, DeepSWE, QwenSWEBench, CoWorkBench, LiveCodeBench — despite being a much smaller, open-weight dense model.
- Opus4.6 Max still leads on broad reasoning (GPQA Diamond, HLE) and on raw terminal-agent execution (Terminal-Bench 2.1), which tracks with it being positioned as a frontier-scale reference model.
- Muse Glimmer-30B trails across the board wherever it has reported numbers, despite being similarly sized to Qwen3.8-27B.
Vision-Language Performance
| Benchmark | Qwen3.8-27B | Qwen3.6-27B | Qwen3.7-Plus | Muse Glimmer-30B | Opus4.6 Max |
|---|---|---|---|---|---|
| OSWorld-Verified (computer use) | 84.3 | 63.9 | 73.3 | 65.9 | 72.7 |
| WebArena-Verified (browser use) | 64.8 | 48.8 | 55.3 | — | — |
| AndroidWorld (mobile use) | 81.9 | 70.3 | 81.0 | — | 62.0 |
| RecreationBench (app recreation) | 47.1 | 29.8 | 30.2 | — | — |
| SWE-MM (multimodal SWE) | 38.6 | 25.7 | 30.0 | — | 27.1 |
| Vision2Web | 62.9 | 45.0 | 42.1 | — | — |
| MathVision (with CI) | 94.6 | — | 90.3 | — | — |
| BabyVision (with CI) | 85.6 | 28.9 | 70.4 | — | — |
| OmniDocBench 1.5 | 91.1 | 89.4 | 91.4 | 75.8 | 86.6 |
| RealWorldQA | 85.9 | 84.1 | 86.9 | — | 73.9 |
| ERQA (embodied reasoning) | 65.5 | 62.5 | 69.8 | — | 40.8 |
This is where Qwen3.8-27B really separates itself: it's a near clean sweep on agentic multimodal tasks — computer use, browser use, mobile use, app recreation. Interestingly, on these categories it even outperforms Opus4.6 Max by wide margins (e.g., 84.3 vs 72.7 on OSWorld, 81.9 vs 62.0 on AndroidWorld). For plain visual perception tasks like document understanding or real-world QA, though, its own sibling Qwen3.7-Plus edges it out slightly, suggesting Qwen3.7-Plus may be tuned more for static visual understanding while Qwen3.8-27B is optimized for acting on what it sees.
Caveat: these are all Qwen-reported numbers, evaluated largely through the Claude Code harness per their own methodology notes, with some benchmark ground-truth corrections applied by Qwen. As always with vendor-published benchmarks, treat them as a starting point rather than gospel — independent replication is worth watching for.
How to Run It
Qwen3.8-27B works with the standard open-source serving stack.
Via Transformers:
from transformers import pipeline
pipe = pipeline("image-text-to-text", model="Qwen/Qwen3.8-27B")
messages = [
{
"role": "user",
"content": [
{"type": "image", "url": "https://example.com/image.jpg"},
{"type": "text", "text": "What's in this image?"}
]
}
]
pipe(text=messages)
Via vLLM:
pip install vllm
vllm serve "Qwen/Qwen3.8-27B"
Via SGLang:
pip install sglang
python3 -m sglang.launch_server --model-path "Qwen/Qwen3.8-27B" --host 0.0.0.0 --port 30000
Both frameworks expose an OpenAI-compatible chat completions endpoint, so it's a drop-in swap if you're already using the OpenAI SDK.
Thinking Mode and Reasoning Effort
Qwen3.8 reasons by default, wrapping its internal chain-of-thought in <think>...</think> before the final answer. You control this with two knobs:
-
reasoning_effort:xhigh(default, thorough),medium(balanced), orlow(fast/cheap) -
enable_thinking: set toFalseviachat_template_kwargsto skip reasoning entirely for latency-sensitive use cases
There's also preserve_thinking, which keeps reasoning traces from earlier turns in a multi-turn conversation — useful for agents where consistent decision-making across steps matters, and it also improves KV-cache reuse.
Recommended Sampling Parameters
- Thinking mode: temperature 1.0, top_p 0.95, top_k 20, repetition_penalty 1.0
- Non-thinking mode: temperature 0.7, top_p 0.80, top_k 20, presence_penalty 1.5
Going Beyond 262K Context
For inputs longer than the native 262,144-token window, Qwen recommends enabling YaRN RoPE scaling (supported in vLLM, SGLang, and TokenSpeed) rather than just cranking up max-model-len blindly, since static YaRN implementations trade off some short-context performance for the extended range.
Where It Fits
If you're choosing between models for a project, here's roughly how I'd frame it:
- Pick Qwen3.8-27B if: you need a self-hostable, Apache-2.0 model for coding agents, computer-use/browser-use automation, or long-document/video understanding, and you want frontier-adjacent performance without frontier-model pricing or lock-in.
- Consider Qwen3.7-Plus if: your workload leans more toward static document/image understanding rather than agentic action-taking — it edges out 3.8 on a few perception-heavy benchmarks.
- Consider Opus4.6 Max if: you need the strongest general reasoning (GPQA, HLE) or terminal-agent execution and don't mind using a closed, hosted frontier model.
- Qwen3.6-27B is now clearly the previous generation — worth upgrading from if you're already on it.
Final Thoughts
What stands out most about Qwen3.8-27B isn't any single benchmark number — it's that a 27B dense model is competitive with (and in agentic/computer-use categories, sometimes ahead of) models presumed to be many times larger. Combined with the Apache 2.0 license, native multimodality, million-token context ceiling, and tunable reasoning effort, it's a genuinely compelling option for anyone building coding agents, computer-use automation, or document/video-understanding pipelines who wants to self-host rather than depend entirely on a closed API.
If you're experimenting with it, I'd love to hear how it performs on your own workloads in the comments.
Model card and benchmark data sourced from the official Qwen3.8-27B model page on Hugging Face.
Top comments (2)
The licensing and context window are the obvious hooks, but the cost question is the one I would underwrite first. A 27B model only changes the deployment math if the serving stack keeps latency and memory predictable under real multimodal workloads. Otherwise the benchmark delta becomes a cloud bill with nicer prose.
Fair the architecture (linear attention on 3/4 layers) is built for that latency/memory math, but Qwen’s benchmarks don’t show it under real concurrent multimodal load. That’s a serving-stack question, not a benchmark-table one. Would need to actually load-test throughput/memory before trusting the “smaller = cheaper” pitch. Good flag might do a follow-up once I’ve run that.