Qwen 3.8-27B Complete Guide: Vision, Tool Use, and a Real Upgrade Over 3.6-27B (2026)
Qwen 3.8-27B is Alibaba’s compact, deployment-friendly model in the new Qwen 3.8 generation. It is a 27 billion parameter dense model, built on the Qwen3.5 architecture, and it is the direct successor to Qwen 3.6-27B, one of the most-used local coding models on this site. The headline change is not raw parameter count. It is native vision-language understanding plus a large jump in agentic coding and long-horizon task benchmarks, while staying on the same permissive Apache 2.0 license.
This guide covers the architecture, the benchmark gains over 3.6-27B, hardware requirements, and how to run it locally. If you already run Qwen 3.6-27B and are deciding whether to upgrade, the benchmark section below has the numbers you need.
What is Qwen 3.8-27B?
Qwen 3.8-27B is the compact, dense model in the Qwen 3.8 family, Alibaba’s newest generation following Qwen 3.6 and 3.7. It is separate from Qwen 3.8 Max, the 2.4 trillion parameter Mixture-of-Experts flagship in the same generation. Where Qwen 3.8 Max targets frontier-scale capability behind an API and a restrictive custom license, Qwen 3.8-27B is a dense model you can download, run locally, and modify under Apache 2.0.
Key specs:
- Parameters: 27 billion (all active, dense)
- Architecture: Causal language model with a native vision encoder, built on the Qwen3.5 foundation
- Layers: 64, in a 3:1 hybrid pattern of Gated DeltaNet (linear attention) and Gated Attention (full attention)
- Hidden dimension: 5,120
- Vocabulary: 248,320 tokens
- Context window: 262,144 tokens natively, extensible to 1,000,000 tokens via YaRN
- Modalities: Text, image, and video input; text output
- License: Apache 2.0
- Multi-Token Prediction (MTP): Trained in, supports speculative decoding
Like the rest of the Qwen 3.8 line, thinking mode is on by default. You can adjust reasoning depth with a reasoning_effort parameter (xhigh, medium, or low), and the model supports preserve_thinking to retain chain-of-thought across multi-turn agent conversations, which helps with decision consistency in long agent loops.
Qwen 3.8-27B vs Qwen 3.6-27B: what actually changed
This is the comparison that matters if you already have a Qwen 3.6-27B setup. Based on Alibaba’s published benchmark table on the model card:
| Benchmark | Qwen 3.8-27B | Qwen 3.6-27B | Change |
|---|---|---|---|
| Agentic terminal coding (Terminal-Bench 2.1) | 73.0% | 63.4% | +9.6 |
| Agentic coding (SWE-bench Pro) | 61.7% | 53.5% | +8.2 |
| Agentic coding (DeepSWE 1.1) | 42.2% | 13.3% | +28.9 |
| Software engineering (QwenSWEBench, in-house) | 79.0% | 49.3% | +29.7 |
| Long-horizon office work (CoWorkBench) | 70.7% | 61.0% | +9.7 |
| Professional job tasks (JobBench) | 33.4% | 21.8% | +11.6 |
| Competitive coding (LiveCodeBench v6) | 90.3% | 83.9% | +6.4 |
| Computer use (OSWorld-Verified) | 84.3% | 63.9% | +20.4 |
| Browser use (WebArena-Verified) | 64.8% | 48.8% | +16.0 |
Two things stand out. First, the DeepSWE and QwenSWEBench jumps (roughly 29 points each) are far larger than the other gains, which suggests Alibaba specifically targeted agentic, multi-step software engineering workflows in this generation rather than just raw code completion. Second, the computer-use and browser-use scores (OSWorld-Verified, WebArena-Verified) did not exist as meaningful capabilities in 3.6-27B’s positioning at all. Vision-language understanding is genuinely new, not a benchmark afterthought.
Note that Alibaba’s own benchmark table evaluates SWE-bench Pro, DeepSWE 1.1, and QwenSWEBench using the Claude Code harness, and these are vendor-published numbers. Treat them as a strong signal of the direction of improvement rather than a fully independent verification.
On raw text-only tasks the gap is smaller. Instruction following (79.5% vs 69.1%) and general knowledge (HLE, 22.0% vs prior generation figures not published for 3.6-27B at this cut) improve too, but the agentic and multimodal numbers are where this release earns its upgrade.
Qwen 3.8-27B vs Qwen 3.8 Max: dense vs MoE, Apache 2.0 vs restricted
Both models were open-weighted in the same August 2026 release window, but they solve different problems.
| Feature | Qwen 3.8-27B | Qwen 3.8 Max (2.4T-A95B) |
|---|---|---|
| Architecture | Dense | Sparse MoE |
| Total parameters | 27B | 2.4 trillion |
| Active parameters | 27B (all) | 95B per token |
| License | Apache 2.0 | Custom Qwen3.8-Max License (not Apache 2.0) |
| Context (native) | 262,144 tokens | 262,144 tokens |
| Context (extended) | 1,000,000 tokens | ~1,010,000 tokens |
| Vision-language | Yes, native | Yes |
| Realistic local deployment | Yes, consumer GPU with quantization | No, needs datacenter-class hardware even quantized |
| Best for | Local coding agents, on-device vision tasks | Frontier-class API workloads, hosted deployment |
If you want a model you can actually run on your own hardware, Qwen 3.8-27B is the one to use. Qwen 3.8 Max is aimed at API consumption or organizations with serious GPU infrastructure. See our Qwen 3.8 Max guide for the full picture on that model, including its licensing details and hosted pricing.
Hardware requirements
Qwen 3.8-27B ships as BF16 weights (roughly 55.6 GB) with community quantizations already available at release.
| Configuration | Size / VRAM | Notes |
|---|---|---|
| BF16 (full precision) | ~55.6 GB | Multi-GPU or high-end workstation card |
| NVFP4 (W4A4) | ~20.6 GB | Fits a single 24 GB consumer GPU with headroom |
| NVFP4 + MTP, dual 16 GB GPUs | Works with tensor parallelism | Community-reported ~160K-token context on 2x RTX 5070 Ti |
| GGUF quantized (llama.cpp, Ollama) | Varies by quant level | Standard llama.cpp quantization ladder applies |
The practical takeaway: this model was designed to be runnable on a single high-end consumer GPU (24 GB class) once quantized, and it can even be split across two mid-range 16 GB cards using vLLM tensor parallelism, according to community-reported configurations. That is a meaningfully lower bar than Qwen 3.8 Max, which requires datacenter GPUs regardless of quantization.
If your hardware matches what worked for Qwen 3.6-27B (a Mac with 22-32GB unified memory, or a single RTX 4090), expect similar or slightly higher requirements here due to the added vision encoder, but nothing that changes the class of hardware you need.
How to run Qwen 3.8-27B
vLLM
pip install vllm
vllm serve Qwen/Qwen3.8-27B \
--reasoning-parser qwen3 \
--max-model-len 262144SGLang
pip install "sglang[all]"
python -m sglang.launch_server \
--model-path Qwen/Qwen3.8-27B \
--reasoning-parser qwen3Hugging Face Transformers
from transformers import pipeline
pipe = pipeline("image-text-to-text", model="Qwen/Qwen3.8-27B")
messages = [
{
"role": "user",
"content": [
{"type": "text", "text": "Write a Python function to merge two sorted linked lists."}
],
}
]
result = pipe(text=messages)
print(result)Long-context setup with YaRN
Qwen 3.8-27B natively supports 262,144 tokens. To go beyond that up to 1,000,000 tokens, enable YaRN scaling:
VLLM_ALLOW_LONG_MAX_MODEL_LEN=1 vllm serve Qwen/Qwen3.8-27B \
--hf-overrides '{"text_config": {"rope_parameters": {"mrope_interleaved": true, "mrope_section": [11, 11, 10], "rope_type": "yarn", "rope_theta": 10000000, "partial_rotary_factor": 0.25, "factor": 4.0, "original_max_position_embeddings": 262144}}}' \
--max-model-len 1000000Only enable this when you actually need contexts beyond 262K. Alibaba’s own documentation notes that static YaRN scaling can slightly reduce quality on shorter texts, since the scaling factor stays fixed regardless of input length.
Vision and agentic capabilities
The native vision-language support is the biggest functional difference from Qwen 3.6-27B. Qwen 3.8-27B can process:
- STEM diagrams and technical documents
- Hour-scale video content
- Screenshots for UI understanding and frontend reconstruction tasks
Combined with the agentic gains (computer use, browser use, tool calling), this makes Qwen 3.8-27B a realistic candidate for local computer-use agents, not just a code-completion model. If you are building or evaluating local AI agents, the OSWorld-Verified and WebArena-Verified scores are the numbers to check against your specific workload before committing.
FAQ
Is Qwen 3.8-27B better than Qwen 3.6-27B?
For agentic coding, multi-step software engineering, and any vision or computer-use task, yes, by a wide margin based on Alibaba’s published benchmarks (DeepSWE 1.1 nearly triples, from 13.3% to 42.2%). For simple single-turn code generation, the gap is smaller. If you don’t need vision input or long-horizon agent workflows, Qwen 3.6-27B remains a capable, well-tested option.
Is Qwen 3.8-27B open source?
Yes. It ships under the Apache 2.0 license, which permits commercial use, modification, and redistribution. This is a meaningfully more permissive license than Qwen 3.8 Max, which uses a custom Qwen3.8-Max License.
Can I run Qwen 3.8-27B on a single consumer GPU?
Yes, with quantization. Community NVFP4 quantized builds run in roughly 20.6 GB, which fits a single 24 GB GPU (like an RTX 4090) with room to spare. GGUF quantizations for llama.cpp and Ollama are also available for lower VRAM budgets.
What is the difference between Qwen 3.8-27B and Qwen 3.8 Max?
Qwen 3.8-27B is a 27B dense model you can run locally under Apache 2.0. Qwen 3.8 Max (built on Qwen3.8-2.4T-A95B) is a 2.4 trillion parameter Mixture-of-Experts model aimed at frontier-class API usage, released under a separate, more restrictive custom license. See our Qwen 3.8 Max complete guide for details.
Does Qwen 3.8-27B support tool calling and agents?
Yes. It supports function calling and shows strong gains on agentic benchmarks like SWE-bench Pro, CoWorkBench, and JobBench compared to the prior generation. Reasoning depth is configurable via reasoning_effort, and preserve_thinking keeps reasoning context across agent turns.