Qwen 3.8 27B Release Notes

Qwen 3.8 27B delivers frontier-level coding and agentic capabilities in a compact 27B dense model

Qwen 3.8 27B is the most capable generation in the Qwen open-model family to date, built on the architectural foundation of Qwen 3.5. It provides substantial gains in coding, professional research, and long-horizon agentic tasks, while maintaining a deployment-friendly size. Notably, it is a native vision-language model capable of understanding images and hour-scale videos.

Core Technical Specifications

Qwen 3.8 27B is a Causal Language Model with an integrated Vision Encoder. It is a dense model (non-MoE) with the following architecture:

  • Parameters: 27 Billion
  • Hidden Dimension: 5120
  • Layers: 64
  • Context Length: 262,144 tokens natively, extensible up to 1,000,000 tokens via RoPE scaling (e.g., YaRN).
  • Architecture Layout: 16 × (3 × (Gated DeltaNet → FFN) → 1 × (Gated Attention → FFN))
  • MTP (Multi-Token Prediction): Trained with multiple steps to improve inference efficiency.

Key Feature Enhancements

Flexible Thinking Control

Qwen 3.8 introduces a "thinking mode" that is enabled by default. This allows the model to generate internal reasoning traces (signified by <think> tags) before producing a final answer. Users can control this behavior via:

  • reasoning_effort: Adjusts reasoning depth with three levels: xhigh (default, for complex analysis), medium (balanced), and low (optimized for speed/cost).
  • preserve_thinking: Enabled by default, this retains reasoning blocks from historical messages to maintain context continuity and improve KV cache utilization.
  • Instruct Mode: Thinking can be disabled entirely for direct responses.

Native Multimodal Intelligence

The model supports native image and video understanding, ranging from STEM diagrams and documents to hour-scale videos. It demonstrates high proficiency in "Computer Use" scenarios, including OSWorld, WebArena, and AndroidWorld.

Benchmark Performance

Qwen 3.8 27B shows significant improvements over Qwen 3.6 27B and competes closely with larger frontier models like Opus 4.6 Max.

Text and Coding Performance

Benchmark Qwen 3.8 27B Qwen 3.6 27B Opus 4.6 Max
SWE-bench Pro (Agentic Coding) 61.7 53.5 53.4
QwenSWEBench (Software Eng) 79.0 49.3 63.8
CoWorkBench (Office Work) 70.7 61.0 68.2
LiveCodeBench v6 (Competitive Coding) 90.3 83.9 88.8
IFBench (Instruction Following) 79.5 69.1 62.5

Vision-Language (VL) Performance

Benchmark Qwen 3.8 27B Qwen 3.6 27B Opus 4.6 Max
OSWorld-Verified (Computer Use) 84.3 63.9 72.7
WebArena-Verified (Browser Use) 64.8 48.8 --
AndroidWorld (Mobile Use) 81.9 70.3 62.0
MathVision (Visual Math) 94.6 (With CI) 85.1 65.5

Deployment and Serving Best Practices

Recommended Frameworks

For production workloads, the Qwen team recommends using dedicated serving engines:

  • SGLang, vLLM, or TokenSpeed.
  • FP8 Quantization: The released FP8-quantized weights use fine-grained quantization (block size 128), resulting in performance nearly identical to the original model.

Sampling Parameters

  • Thinking Mode: temperature=1.0, top_p=0.95, top_k=20, min_p=0.0, presence_penalty=0.0, repetition_penalty=1.0
  • Instruct Mode: temperature=0.7, top_p=0.80, top_k=20, min_p=0.0, presence_penalty=1.5, repetition_penalty=1.0

Long Context Handling

To extend context to 1M tokens, users should modify the rope_parameters in config.json to use rope_type: "yarn" with a factor of 4.0. The team warns that static YaRN may impact performance on shorter texts and suggests adjusting the factor based on typical application length.

Community Insights and Observations

Community feedback from Hacker News highlights several practical deployment experiences:

  • Hardware Performance: Users report successful deployment on various hardware, including RTX 3090s and M5 Max MacBooks. One user noted that using the ninfer engine on an RTX 5090 achieved ~138 tokens/second.
  • Reasoning Behavior: Some users observed that the xhigh reasoning mode can lead to "overthinking" or "bushy code," suggesting that medium or low effort may be more appropriate for simpler tasks.
  • Comparison to MoE: Some developers expressed a preference for Mixture-of-Experts (MoE) models (like the 35B A3B) for better efficiency on lower-end hardware (e.g., M1 Max), noting that the 27B dense model can be memory-hungry.
  • Real-world Utility: Multiple users reported that the model "feels like Opus 4.5/4.6" in practice, particularly for complex coding tasks and SVG generation.

"I gave it an image and a broad overview of what I wanted it to build, and it built the whole thing from beginning to end." — @swalsh

Sources

Related