Qwen3.8-27B

Model Ecosystem

Model Tree for Qwen/Qwen3.8-27B

Adapters

• 40 models based on Qwen3.8-27B

Finetunes

• 174 models fine-tuned from Qwen3.8-27B

Merges

• 4 merge models

Quantizations

• 759 quantized models (llama.cpp, LM Studio, Jan, Ollama)

Collection

Part of the Qwen3.8 Collection — 4 items, updated 10 days ago, 403 entries.

Community

• 159 community discussions on HuggingFace
• 31 Spaces using Qwen3.8-27B

Related Models in Qwen3.8 Family

• Qwen3.8-27B (this model) — 27B dense, vision-language
• Qwen3.8-2.4T-A95B — 2.4T MoE, 95B active parameters
• Qwen3.8-Max — Closed-source flagship
• Qwen3.8-Plus — Closed-source mid-tier

Citation

If you find our work helpful, feel free to give us a cite.

@misc{qwen38,
    title = {{Qwen3.8-Max}: A New Bar for Coding and Cowork},
    url = {https://qwen.ai/blog?id=qwen3.8},
    author = {{Qwen Team}},
    month = {August},
    year = {2026}
}

Context Length

Native Context Length

• 262,144 tokens (256K) natively supported.

Extended Context Length

• Up to 1,000,000 tokens (1M) with RoPE scaling.

RoPE Scaling (YaRN)

For tasks exceeding the native 262K context, YaRN (Yet another RoPE extensioN) is recommended.

Supported frameworks: vLLM, SGLang, TokenSpeed.

Configuration 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
}

Key notes:

• All open-source frameworks implement static YaRN — scaling factor is constant regardless of input length.
• May impact performance on shorter texts.
• Only modify rope_parameters when long contexts are required.
• Adjust factor as needed: e.g., factor=2.0 for 524,288 tokens, factor=4.0 for 1,000,000 tokens.

Qwen Cloud Hosted Version

• 1M context length by default.

Vision-Language Understanding

Qwen3.8-27B is a native vision-language model that understands images and videos.

Capabilities

• Image Understanding: STEM diagrams, documents, charts, real-world images, and visual reasoning tasks.
• Video Understanding: Hour-scale videos with configurable frame sampling.
• Multimodal Agentic Tasks: Computer use, browser use, mobile use, application recreation, and visual web development.

Input Modalities

• Text: Standard text input via chat completions API.
• Image: Image URLs supported directly in message content.
• Video: Video URLs supported with configurable frame sampling (fps parameter, default 2 fps).

Key Vision Benchmarks

• OSWorld-Verified (Computer use): 84.3
• WebArena-Verified (Browser use): 64.8
• AndroidWorld (Mobile use): 81.9
• MathVision (With CI): 94.6
• BabyVision (With CI): 85.6
• OmniDocBench 1.5 (Document intelligence): 91.1
• RealWorldQA (Real-world perception): 85.9

Long Video Optimization

For hour-scale videos, set longest_edge in video_preprocessor_config.json to 469,762,048 (224k video tokens) for higher frame-rate sampling.

Video frame sampling can be configured via extra_body in vLLM with mm_processor_kwargs (fps, do_sample_frames).

Flexible Thinking Control

Qwen3.8-27B operates in thinking mode by default, generating structured reasoning before producing the final response. The model provides several flexible controls:

Thinking Mode Toggle

• Thinking ON (default): The model generates thinking content wrapped in \u003cthink\u003e...\u003c/think\u003e tags before the final response.
• Thinking OFF: Can be disabled per request by setting enable_thinking: False in chat_template_kwargs.

reasoning_effort Levels

Qwen3.8 supports official reasoning_effort to adjust reasoning depth and control cost:

• xhigh (default): For complex tasks demanding thorough analysis
• medium: Balancing accuracy and speed
• low: Efficient reasoning optimizing for speed and cost

In multi-turn agentic tasks, lower reasoning effort does not always reduce overall task completion time. Although it may produce faster per-turn responses, it can also lead to insufficient analysis, more failures, and repeated retries, increasing total latency and token consumption.

preserve_thinking

• Enabled by default for all workloads.
• Retains thinking blocks from all historical messages, maintaining a complete reasoning trace across the conversation.
• Ensures full context continuity, especially beneficial for agent scenarios where decision consistency and reduced redundant reasoning are critical.
• Improves KV cache utilization, optimizing inference efficiency in both thinking and non-thinking modes.
• Can be disabled by setting preserve_thinking: False in chat_template_kwargs.

Qwen Cloud Differences

When using Qwen Cloud APIs:

• Use "enable_thinking": False directly (not wrapped in chat_template_kwargs)
• Use "preserve_thinking": False directly

API Usage

Qwen3.8 models operate in thinking mode by default, generating thinking content signified by \u003cthink\u003e...\u003c/think\u003e before producing the final response.

Chat Completions API

The Chat Completions API can be used with most inference frameworks, as well as Qwen Cloud. Requires the OpenAI Python SDK:

pip install -U openai
export OPENAI_BASE_URL='your-base-url'
export OPENAI_API_KEY='your-api-key'

Text-Only Input

from openai import OpenAI
client = OpenAI()

messages = [{"role": "user", "content": "Write a Python function to merge two sorted linked lists."}]

completion = client.chat.completions.create(
    model="Qwen/Qwen3.8-27B",
    messages=messages,
    extra_body={
        "chat_template_kwargs": {
            "enable_thinking": True,
            "preserve_thinking": True,
        },
    },
    reasoning_effort="xhigh",
    stream=True,
    stream_options={"include_usage": True},
)

Image Input

messages = [
    {"role": "user", "content": [
        {"type": "image_url", "image_url": {"url": "https://..."}},
        {"type": "text", "text": "Describe this image."}
    ]}
]
chat_response = client.chat.completions.create(model="Qwen/Qwen3.8-27B", messages=messages)

Video Input

messages = [
    {"role": "user", "content": [
        {"type": "video_url", "video_url": {"url": "https://..."}},
        {"type": "text", "text": "What happens in this video?"}
    ]}
]
chat_response = client.chat.completions.create(model="Qwen/Qwen3.8-27B", messages=messages)

Instruct (Non-Thinking) Mode

chat_response = client.chat.completions.create(
    model="Qwen/Qwen3.8-27B",
    messages=messages,
    temperature=0.7,
    top_p=0.8,
    presence_penalty=1.5,
    extra_body={
        "top_k": 20,
        "chat_template_kwargs": {"enable_thinking": False},
    },
)

Qwen Cloud Note

If using Qwen Cloud APIs, use "enable_thinking": False directly instead of wrapping in chat_template_kwargs.

Best Practices for Qwen3.8-27B

1. 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 (non-thinking) mode:

• temperature=0.7, top_p=0.80, top_k=20, min_p=0.0, presence_penalty=1.5, repetition_penalty=1.0

For supported frameworks, adjust presence_penalty between 0 and 2 to reduce endless repetition. Higher values may cause language mixing and slight performance decrease.

2. Adequate Output Length

For agentic tasks, allocate sufficient output length:

• Reasoning Content: max output length 262,144 tokens
• Final Response: max output length 131,072 tokens

These settings provide capacity for complex reasoning while ensuring space for high-quality deliverables.

3. Processing Ultra-Long Texts

Qwen3.8-27B natively supports up to 262,144 tokens. For longer contexts, use RoPE scaling (YaRN):

Config file approach — modify rope_parameters in config.json:

{
    "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
}

Command line approach for vLLM:

VLLM_ALLOW_LONG_MAX_MODEL_LEN=1 vllm serve ... --hf-overrides '{"text_config": {"rope_parameters": {...}}}' --max-model-len 1000000

For SGLang:

SGLANG_ALLOW_OVERWRITE_LONGER_CONTEXT_LEN=1 python -m sglang.launch_server ... --json-model-override-args '{...}' --context-length 1000000

For TokenSpeed:

TOKENSPEED_ALLOW_OVERWRITE_LONGER_CONTEXT_LEN=1 tokenspeed serve ... --hf-overrides '{...}' --max-model-len 1000000

All open-source frameworks implement static YaRN — the scaling factor is constant regardless of input length, potentially impacting performance on shorter texts. Only modify rope_parameters when long contexts are required. Adjust factor as needed (e.g., factor=2.0 for 524,288 tokens).

4. Long Video Understanding

The size parameter in video_preprocessor_config.json is conservatively configured. For hour-scale videos, set longest_edge to 469,762,048 (224k video tokens):

{"longest_edge": 469762048, "shortest_edge": 4096}

Alternatively, override via engine startup parameters (see vLLM / SGLang docs).

Serving Qwen3.8-27B

Qwen3.8-27B is compatible with Hugging Face Transformers, vLLM, SGLang, TokenSpeed, and other popular inference frameworks.

Recommended Serving Engines

For production workloads or high-throughput scenarios, dedicated serving engines are recommended:

• SGLang: Qwen3.8 Cookbook
• vLLM: Qwen3.8 Recipe
• TokenSpeed: Qwen3.8 Recipe

Model Format

• Hugging Face Transformers format (Safetensors)
• Compatible with vLLM, SGLang, TokenSpeed, etc.

Qwen Cloud Hosted Service

For managed, scalable inference without infrastructure maintenance, the official Qwen API service is provided by Qwen Cloud. Qwen3.8-27B is available as a hosted version with:

• 1M context length by default
• Official built-in tools
• Qwen3.8-27B Overview

HuggingFace Metadata

• Downloads (last month): 2,358,347
• Likes: 12.2
• Followers: 99,600
• Tags: image-text-to-text, Transformers, Safetensors, qwen3_5, conversational, Eval Results

Vision-Language Performance Benchmarks

Evaluation Notes

• MathVision: Qwen3.8-27B uses fixed prompt with \boxed{} formatting. Other models report higher score from two prompt variants.
• BabyVision, CharXiv: Corrected ground-truth annotations used where available.
• WebArena-Verified: Official grader under OSWorld scaffold.
• RecreationBench: In-house benchmark across desktop (Ubuntu, macOS, Windows), mobile (Android), and web.
• ClawEval-MM: Pass@3 / average score reported.
• Vision2Web: Averaged across frontend, webpage, and website categories. Claude Code harness, judged by gpt-5.4.
• SWE-MM: Claude Code harness, public dev split with modifications per Claude Opus 4.7 system card.
• Best result in each row shown in bold.

Text Performance Benchmarks

Evaluation Notes

• SWE-bench Pro: All models evaluated with Claude Code harness at temp=1.0, top_p=0.95, 256K context window. Opus4.6 Max uses officially reported score.
• NL2Repo-Bench: Evaluated with Claude Code harness. Bash commands accessing the specific repository disabled to prevent reward hacking.
• DeepSWE 1.1: Claude Code harness at temp=1.0, top_p=0.95, 256K context window.
• QwenSWEBench: In-house coding benchmark, Claude Code harness, avg@3, 8-hour timeout, max_tokens=32,768, temp=1.0, 256K context.
• CoWorkBench: In-house benchmark for long-horizon tasks across CS, finance, law, medical, and productivity domains.
• HLE: Judged by GPT-4o.
• Best result in each row shown in bold. Empty cells (--) indicate not available.

Qwen3.8 Highlights

Following the widespread community adoption of the Qwen3.5 and Qwen3.6 series, Qwen3.8 is the most capable generation in the Qwen open-model family to date.

Built on the architectural foundation of Qwen3.5, Qwen3.8 delivers substantial gains across coding, professional work, research, and long-horizon agentic tasks.

Key Enhancements

• Core Capabilities: Comprehensive improvements across coding, professional work, research, and long-horizon agentic tasks.
• Agent Execution: Stronger autonomous planning and better handling of environment feedback, leading to more reliable end-to-end task completion.
• Downstream Compatibility: Broader support for popular harnesses and development tools, making it easier to integrate into your existing stack.
• Flexible Thinking Control: Thinking mode is on by default and can be disabled per request; reasoning depth can be tuned with reasoning_effort, and reasoning context from historical messages is retained via preserve_thinking.
• Vision-Language Understanding: Native support for image and video understanding, from STEM diagrams and documents to hour-scale videos.

Qwen3.8-27B Specifics

A compact, deployment-friendly dense model: a native vision-language model that understands images and videos, with flexible thinking control, designed to carry complex, multi-step tasks through to completion with greater reliability.

Model Architecture

• Type: Causal Language Model with Vision Encoder
• Training Stage: Pre-training & Post-training

Language Model

• Number of Parameters: 27B
• Hidden Dimension: 5,120
• Token Embedding: 248,320 (Padded)
• Number of Layers: 64
• Hidden Layout: 16 × (3 × (Gated DeltaNet → FFN) → 1 × (Gated Attention → FFN))

Gated DeltaNet

• Number of Linear Attention Heads: 48 for V and 16 for QK
• Head Dimension: 128

Gated Attention

• Number of Attention Heads: 24 for Q and 4 for KV
• Head Dimension: 256
• Rotary Position Embedding Dimension: 64

Feed Forward Network

• Intermediate Dimension: 17,408

Output & MTP

• LM Output: 248,320 (Padded)
• MTP (Multi-Token Prediction): trained with multiple steps

Tensor Type

• BF16

Model Size

• 28B params (with embedding padding)