This is a simplified guide to an AI model called Qwen3.8-27b maintained by Qwen. If you like these kinds of analysis, you should join AImodels.fyi or follow us on Twitter.
Overview
Qwen3.8-27B is a 27-billion-parameter dense language model with integrated vision capabilities, built by Qwen on the architectural foundation of Qwen3.5. This causal language model with vision encoder supports native image and video understanding, making it suitable for multimodal reasoning tasks that require understanding both textual and visual information. The model has 64 layers, a hidden dimension of 5120, and uses a hybrid attention architecture combining Gated DeltaNet (with 48 linear attention heads for V and 16 for QK, each with 128-dimensional heads) and Gated Attention (24 heads for Q and 4 for KV, each with 256-dimensional heads). It features a native context window of 262,144 tokens and extends up to 1,000,000 tokens. The model was trained with multi-token prediction (MTP), enabling faster inference. It operates in thinking mode by default, generating explicit reasoning steps before producing final responses, though this can be disabled per request. Implemented in Hugging Face Transformers format, it is also compatible with vLLM, SGLang, TokenSpeed, and other inference frameworks. The most important consideration before using this model is that thinking mode is enabled by default and generates extended reasoning chains that consume additional tokens; you must explicitly configure parameters or disable thinking mode if you need direct, cost-efficient responses.
Best use cases
Software engineering and agentic coding tasks. Qwen3.8-27B achieves 61.7% on SWE-bench Pro, 73.0% on Terminal Bench 2.1 (Terminus), and 42.2% on DeepSWE 1.1, outperforming earlier Qwen variants and matching or beating comparable models on code generation. The model's strong performance on code-to-repository generation (42.3% on NL2Repo-Bench) makes it suited to tasks requiring understanding of large codebases, generating patches, and executing multi-step software engineering workflows. The thinking mode with tunable reasoning effort is particularly effective here because coding problems often require planning multiple steps before implementation.
Multimodal computer use and visual navigation tasks. The model achieves 84.3% on OSWorld-Verified (computer use), 64.8% on WebArena-Verified (browser use), and 81.9% on AndroidWorld (mobile use), demonstrating strong capabilities in understanding and interacting with graphical interfaces. This makes it suitable for automation tasks involving desktop applications, web browsers, and mobile applications where the model must interpret screenshots and execute appropriate actions. The native video understanding capability extends this to analyzing hour-scale videos, useful for video-based automation and monitoring scenarios.
Mathematical and scientific reasoning with visual components. The model scores 90.0% without chain-of-thought and 94.6% with chain-of-thought on MathVision, 83.7% to 90.2% on CharXiv (scientific chart analysis), and 91.1% on OmniDocBench 1.5 (document intelligence). These benchmarks reveal capability in parsing complex visual information—diagrams, equations, charts, scientific papers—and performing reasoning over this content. Tasks like automated document processing, scientific paper analysis, and homework help benefit from the combination of vision understanding and mathematical reasoning.
Long-horizon planning and multi-turn agentic tasks. The model achieves 70.7% on CoWorkBench (office work tasks), 33.4% on JobBench (professional job tasks), and 20.4% on Agents' Last Exam, outperforming earlier Qwen variants. The preserve_thinking feature enabled by default allows the model to retain reasoning context across multiple conversation turns, making it effective for complex workflows requiring sustained problem-solving, iterative refinement, and adaptation to environment feedback. However, lower reasoning effort settings in multi-turn tasks may actually increase total latency due to insufficient analysis leading to more failures and retries.
Document understanding and professional work. With OmniDocBench 1.5 performance at 91.1% and RealWorldQA at 85.9%, the model handles structured documents, PDFs, and professional materials effectively. This applies to invoice processing, contract analysis, research paper summarization, and other document-heavy workflows where visual layout and structure matter as much as text content.
Limitations
The model's default thinking mode generates extended reasoning chains marked by <think>...</think> tags before producing responses. This increases token consumption and latency for every query unless explicitly disabled, raising costs for simple requests that do not benefit from extended reasoning. The generated thinking content is substantial and must be parsed or handled separately in production applications.
Hardware requirements are significant for deployment. A 27B dense model requires substantial GPU memory; while exact VRAM requirements are not specified in the documentation, comparable models of this size typically require 50GB+ of VRAM for full precision inference. Quantization options are mentioned as available through various frameworks but specific quantization schemes (e.g., 8-bit, 4-bit) are not detailed in the provided documentation.
Inference speed characteristics are not quantified in the README. The documentation states that "inference efficiency and throughput vary significantly across frameworks" and recommends using latest versions of SGLang, vLLM, or TokenSpeed for production workloads, but no concrete benchmarks—tokens-per-second, latency in milliseconds—are provided for standard inference scenarios.
The model's vision capabilities, while strong, are trained on specific benchmark domains. Performance generalizes well to document understanding and structured visual content but may degrade on edge cases or visual styles not well represented in training data. Real-world perception benchmarks (RealWorldQA at 85.9%, ERQA at 65.5%) show respectable but not perfect performance on arbitrary real-world images.
Reasoning effort control via the reasoning_effort parameter includes three levels (xhigh, medium, low), but the documentation provides no concrete data on the quality/cost tradeoffs at each level or guidance on which settings suit which tasks beyond stating that lower effort on multi-turn tasks can paradoxically increase total cost and latency due to failed attempts.
The model's thinking mode may not be appropriate for applications requiring minimal latency or deterministic response times, such as real-time interactive systems. Disabling thinking requires explicit configuration, and the model defaults to the slower thinking-enabled path.
The native context window of 262,144 tokens, while substantial, is shorter than some contemporary models. The 1,000,000 token extension requires specialized handling and is not documented as natively efficient.
How it compares
Qwen3.6-27B is the direct predecessor to this model. Choose Qwen3.8-27B if you prioritize the latest improvements in coding (61.7% vs 53.5% on SWE-bench Pro), agentic tasks (70.7% vs 61.0% on CoWorkBench), and multimodal computer use (84.3% vs 63.9% on OSWorld-Verified). Choose Qwen3.6-27B if you need a mature, battle-tested model with lower computational overhead or if documentation and tooling for that version is more mature in your deployment environment.
Qwen3.8-2.4T-A95B is the much larger mixture-of-experts variant in the same generation. Choose Qwen3.8-27B for deployment on constrained hardware, lower latency inference, and smaller model footprint. Choose Qwen3.8-2.4T-A95B if maximum capability is the priority and you have infrastructure to support a 2.4T parameter model with routing overhead.
Qwen3.5-27B is an earlier generation model in the same dense 27B class. Qwen3.8-27B delivers significantly better results across coding (73.0% vs unspecified on Terminal Bench), agentic tasks, and multimodal understanding. Qwen3.5-27B may still be preferable if you have optimized inference infrastructure already built for it or require a lighter-weight model.
Qwen3.5-397B-A17B-FP8 represents a much larger dense model from an earlier generation. Choose Qwen3.8-27B for efficient deployment and lower latency. Choose the 397B model only if you need maximum capability across all benchmarks and have the infrastructure to support it.
Technical specifications
Architecture and parameters:
- Type: Causal language model with vision encoder
- Parameters: 27 billion (dense, non-mixture-of-experts)
- Hidden dimension: 5120
- Token embedding dimension: 248,320 (padded)
- Layers: 64 total, arranged as 16 groups of (3 Gated DeltaNet→FFN blocks and 1 Gated Attention→FFN block)
- Gated DeltaNet attention: 48 linear attention heads (V) and 16 linear attention heads (QK), each with 128-dimensional head
- Gated Attention: 24 attention heads (Q) and 4 key-value heads (KV), each with 256-dimensional head
- Rotary position embeddings: 64-dimensional
- FFN intermediate dimension: 17,408
- Output embedding dimension: 248,320 (padded)
- Training includes multi-token prediction (MTP) across multiple steps
Context and sequence handling:
- Native context window: 262,144 tokens
- Extensible context: up to 1,000,000 tokens
Training and capabilities:
- Training stage: Pre-training and post-training
- Trained with thinking mode enabled by default
- Supports flexible reasoning control via
reasoning_effortparameter (three levels:xhighdefault,medium,low) -
preserve_thinkingenabled by default to retain reasoning context across multi-turn conversations
Framework compatibility and deployment:
- Native format: Hugging Face Transformers
- Compatible frameworks: Hugging Face Transformers, vLLM, SGLang, TokenSpeed
- Model loading: Standard transformers library or specialized inference engines
- Hosted inference: Available via Qwen Cloud (coming soon) with 1M context length, built-in tools, and additional production features
Sampling parameters (recommended by Qwen):
- 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
Licensing:
- Apache 2.0 license
Model inputs and outputs
Inputs
- Text prompts (single or multi-turn conversation messages)
- Images (format not specified; implementation via transformers handles standard formats)
- Videos (hour-scale support; format and preprocessing requirements not specified)
- Vision-language prompts combining text, images, and video
- Optional parameters:
reasoning_effortto control depth of reasoning,preserve_thinkingto enable/disable reasoning context retention across turns
Outputs
- Generated text with optional reasoning chains wrapped in
<think>\n...\n</think>\n\nmarkers when thinking mode is enabled - Thinking mode disabled produces direct text response without reasoning content
- Streaming output compatible with OpenAI Chat Completions API format
- Token count and usage information via API responses
Getting started
from openai import OpenAI
# Configure with your API base URL and key
# export OPENAI_BASE_URL='your-base-url'
# export OPENAI_API_KEY='your-api-key'
client = OpenAI()
# Text-only input with thinking enabled (default)
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={
"reasoning_effort": "medium" # Can be "low", "medium", or "xhigh"
}
)
print(completion.choices[0].message.content)
# To disable thinking mode and get direct response
completion_no_think = client.chat.completions.create(
model="Qwen/Qwen3.8-27B",
messages=messages,
extra_body={
"enable_thinking": False
}
)
print(completion_no_think.choices[0].message.content)
For local deployment with vLLM:
pip install vllm
vllm serve Qwen/Qwen3.8-27B --tensor-parallel-size 2
Then use the same OpenAI-compatible client code above with your local vLLM endpoint.
Frequently asked questions
Q: What is the Apache 2.0 license, and can I use this model commercially?
A: The Apache 2.0 license permits commercial use, modification, and distribution provided you include a copy of the license and state significant changes. You can use Qwen3.8-27B in production applications without royalty payments or licensing fees.
Q: What happens if I don't disable thinking mode?
A: By default, the model generates explicit reasoning steps marked with <think> tags before answering. These reasoning tokens consume part of your token budget and increase latency. For simple queries that don't benefit from deep reasoning, this raises costs. Disable thinking by setting enable_thinking=False in the API request or configuring inference parameters appropriately in your framework.
Q: How much GPU memory do I need to run Qwen3.8-27B?
A: Exact VRAM requirements are not specified in the documentation. As a 27B dense model, expect to require 50-70GB of VRAM for full-precision inference on a single GPU. Quantization to 8-bit or 4-bit reduces this significantly, though specific quantized model variants are not documented here. Use frameworks like vLLM or SGLang with quantization support to reduce memory footprint.
Q: How does this model compare to Qwen3.6-27B for coding tasks?
A: Qwen3.8-27B achieves 61.7% on SWE-bench Pro versus 53.5% for Qwen3.6-27B—a substantial 8.2 percentage point improvement. On Terminal Bench 2.1, it scores 73.0% versus 63.4%. The newer model is meaningfully better for software engineering tasks and agentic coding. Qwen3.6-27B may still be preferable if you have existing optimized infrastructure for it or prioritize stability over latest capabilities.
Q: Can I fine-tune Qwen3.8-27B?
A: The model weights are provided in Hugging Face Transformers format, which supports fine-tuning via the transformers library, along with compatible frameworks like vLLM and SGLang. The documentation does not provide specific guidance on fine-tuning procedures, datasets, or recommended hyperparameters for this model.
Q: What is the reasoning_effort parameter, and how does it affect cost and quality?
A: reasoning_effort controls the depth of reasoning (three levels: low, medium, xhigh default). Lower effort produces faster responses with less token consumption but may sacrifice reasoning quality. On multi-turn agentic tasks, using low reasoning effort can paradoxically increase total cost and latency because insufficient analysis leads to more failures and retries. No concrete benchmarks quantifying the quality/cost tradeoffs at each level are provided.
Q: Does this model support video input, and what are the constraints?
A: Yes, Qwen3.8-27B has native support for video understanding up to hour-scale duration. Specific constraints on video format, resolution, frame rate, or preprocessing are not documented. Use the OpenAI Chat Completions API format to submit videos alongside text prompts.
Q: Is Qwen3.8-27B actively maintained and updated?
A: The model is from Qwen's latest generation (Qwen3.8 series, released after widespread adoption of Qwen3.5 and Qwen3.6). A hosted Qwen Cloud version with production features is coming soon. The model is maintained by Qwen and available through official inference services and open-weight variants.
Top comments (0)