Alibaba Opens Qwen3.8-Max Weights, Letting Teams Self-Host a 2.4T Model

Alibaba just made good on a promise. Qwen3.8 open weights are now live on Hugging Face and ModelScope, delivering two very different models for very different hardware budgets: the compact Qwen3.8-27B, a deployment-friendly dense model, and the flagship Qwen3.8-2.4T-A95B, a massive mixture-of-experts (MoE) model that is the first Max-class Qwen release ever made downloadable. Both ship under Apache 2.0.

Two models, one announcement

Alibaba released Qwen3.8-Max as a 2.4-trillion-parameter sparse MoE model with 95 billion active parameters per token. MoE means the model has a huge number of parameters total, but only a fraction of them activate on any given token, keeping inference costs manageable relative to the raw parameter count. This is the first time Qwen is opening the weights of a Max-class model.

Built on the architectural foundation of Qwen3.5, Qwen3.8 delivers substantial gains across coding, professional work, research, and long-horizon agentic tasks. Qwen3.8-27B brings these advances to 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.

The architecture under the hood

Qwen3.8-27B is a dense model, meaning every parameter activates on every token. That makes VRAM usage predictable and latency low, which is exactly what you want for local deployment. But fitting a 262K-token context into a dense 27B model without blowing up memory requires a clever architectural trick.

Qwen3.8-27B is organized as 64 layers, structured as 16 repeating blocks, each composed of three Gated DeltaNet sublayers followed by a single Gated Attention sublayer, with feed-forward networks interleaved throughout. Three-quarters of the model's attention budget runs on linear attention; only every fourth sublayer performs full self-attention. Gated DeltaNet is a form of linear attention: instead of computing relationships between every pair of tokens (which scales as O(n²) and becomes ruinously expensive at 262K tokens), it trades a small amount of expressive capacity for O(n) complexity. Full Gated Attention appears only where it earns its keep , roughly once per block , to preserve the long-range precision that linear attention alone cannot.

The model also ships with Multi-Token Prediction (MTP) trained in, which lets the model predict several tokens at once during inference rather than one at a time, reducing latency on long outputs. Context is 262K tokens natively, and can be extended to 1M tokens via YaRN , a technique that rescales the model's positional encodings to handle sequences longer than it was trained on, without retraining.

What it can actually do

The benchmark story for Qwen3.8-27B is strong, especially for a self-hostable dense model. Compared to its predecessor Qwen3.6-27B and the API-only Qwen3.7-Plus:

• Alibaba published a comprehensive benchmark table comparing Qwen3.8 against top frontier models. On SWE-bench Pro (real-world agentic coding), Qwen3.8-27B scores 61.7 vs. 53.5 for Qwen3.6-27B and 57.6 for Qwen3.7-Plus.
• On LiveCodeBench v6 (competitive coding), it scores 90.3, ahead of both Qwen3.6-27B (83.9) and Qwen3.7-Plus (89.6).
• On CoWorkBench (long-horizon office tasks), it scores 70.7, beating Qwen3.7-Plus (65.1) and even Opus4.6 Max (68.2).
• On OSWorld-Verified (computer use , how well an agent operates a real desktop), it scores 84.3, up from 63.9 for Qwen3.6-27B.
• On AndroidWorld (mobile agent tasks), it scores 81.9, ahead of Opus4.6 Max at 62.0.

Where it falls short: on HLE (broad-knowledge frontier reasoning), it scores 30.8 versus 34.7 for Qwen3.7-Plus and 40.0 for Opus4.6 Max. Deep general knowledge remains a gap relative to the largest proprietary models.

The thinking system

Qwen3.8 models operate in thinking mode by default, generating thinking content signified by <think> ...</think> before producing the final response. You can toggle this per request, and tune how much reasoning effort the model applies:

• xhigh (default): full reasoning for complex tasks
• medium: balanced speed and accuracy
• low: fast, cost-optimized responses

There is also a preserve_thinking flag that retains the model's reasoning traces across conversation turns. In multi-turn agent workflows, this means later turns can reference earlier reasoning chains rather than reconstructing them from scratch, reducing redundant token generation and improving KV-cache utilization.

How to run it

For production workloads or high-throughput scenarios, dedicated serving engines such as SGLang, vLLM, or TokenSpeed are recommended. The quickest way to get started with the 27B model via vLLM:

pip install vllm
vllm serve "Qwen/Qwen3.8-27B"

For multimodal input via the Python SDK:

from transformers import AutoProcessor, AutoModelForMultimodalLM
processor = AutoProcessor.from_pretrained("Qwen/Qwen3.8-27B")
model = AutoModelForMultimodalLM.from_pretrained("Qwen/Qwen3.8-27B", device_map="auto")
messages = [{
    "role": "user",
    "content": [
        {"type": "image", "url": "https://example.com/diagram.jpg"},
        {"type": "text", "text": "Explain this architecture diagram."}
    ]
}]
inputs = processor.apply_chat_template(
    messages, add_generation_prompt=True,
    tokenize=True, return_dict=True, return_tensors="pt"
).to(model.device)
outputs = model.generate(**inputs, max_new_tokens=512)
print(processor.decode(outputs[0][inputs["input_ids"].shape[-1]:]))

To extend context to 1M tokens with YaRN on vLLM:

VLLM_ALLOW_LONG_MAX_MODEL_LEN=1 vllm serve Qwen/Qwen3.8-27B \
  --hf-overrides '{"text_config": {"rope_parameters": {
    "rope_type": "yarn", "factor": 4.0,
    "original_max_position_embeddings": 262144}}}' \
  --max-model-len 1000000

Pricing and access

The weights for both models are free to download under Apache 2.0. The Max model is also available via API on QwenCloud at $2/$6 per million input/output tokens. A hosted version of Qwen3.8-27B with 1M context by default and built-in tools is coming soon to Qwen Cloud. Quantized builds of the 27B model are already available for llama.cpp, Ollama, and LM Studio.

Why this matters beyond the headline

The real story here is not just benchmark numbers. For a model that will be self-hostable, that is a genuinely different proposition than the usual open-weight release that trails the frontier by a generation. The Qwen3.8-27B beats Qwen3.7-Plus , an API-only model , on several key agentic benchmarks, while running locally on a single high-end GPU.

The architecture choice also signals something important about where open-weight models are heading. The Gated DeltaNet hybrid is not just an efficiency trick: it is a deliberate bet that linear attention at scale can match full attention for most real-world tasks, reserving the expensive quadratic attention only where it is strictly necessary. The theme running through Qwen3.8 is autonomy over long horizons. Both models are built around the idea that the most valuable thing a model can do is complete a complex, multi-step task without human intervention , not just answer a single question well.

For teams building coding agents, document pipelines, or computer-use workflows, Qwen3.8-27B is now the most capable open-weight option at its size class. The 2.4T Max model sets a new ceiling for what self-hosted inference can achieve, even if running it requires serious data center hardware.