Qwen3.8-Flash-Next

Updated

Thinking

Tools

Vision

Reasoning

Code

Multilingual

Run

Qwen3.8-Flash-Next carries 125B parameters with 6B active, plus a 51B n-gram embedding. An experimental preview of the Qwen4 architecture.

At a glance

License: Qwen Community License 1.0
Parameters: 125B total with 6B activated, plus 51B n-gram embedding and 4B MTP, about 180B on disk
Context length: 262,144 tokens, extensible to 1,000,000
Modalities: Text, image and video input
Minimum hardware: Not stated by Qwen; smallest published weights are 135.2 GB, the community NVFP4 build

What is Qwen3.8-Flash-Next?

Qwen3.8-Flash-Next is the first open-weight release on a new architecture from Alibaba's Qwen team, published on August 24, 2026. Qwen describes it as an experimental preview of the architecture that will underpin Qwen4, so treat it as a look ahead rather than a finished product line. It accepts text, images and video as input. Its parameter count does not collapse into one number: the language model is 125B with 6B activated per token, and on top of that sit a 51B n-gram embedding and a 4B Multi-Token Prediction head. Counting every weight category, the safetensors files hold about 180B parameters.

Specification	Qwen3.8-Flash-Next
Language model parameters	125B total, 6B activated
N-gram embedding	51B, indexing 20,000,000 bigrams and trigrams at layer 2
Multi-Token Prediction	4B, 1 layer, trained with multiple steps
All weight categories	About 180B in the published safetensors
Architecture	Hybrid, Gated DeltaNet with Qwen Sparse Attention, Gated Residual
Layers	48
Experts	512, with 10 routed plus 1 shared active
Context window	262,144 tokens, extensible to 1,000,000
Modalities	Text, image and video input
Model type	qwen4_exp
Release date	August 24, 2026
License	Qwen Community License 1.0

The layer stack repeats one pattern twelve times: three Gated DeltaNet blocks feeding MoE, then one Qwen Sparse Attention block feeding MoE. QSA picks micro-blocks instead of individual tokens, with a budget of 512 blocks or 2048 tokens, which is where Qwen says the long-context latency saving comes from. The n-gram embedding is the other unusual piece: Qwen scales parameters through embeddings because they need less computation and, in Qwen's words, are easier to offload than MoE weights.

Qwen3.8-Flash-Next benchmarks

Qwen published two tables with the release, one for language and one for vision language. These are the language rows, against Qwen3.8-27B, Qwen3.7-Plus, DeepSeek-V4-Flash and Claude-Opus-4.6 (Max):

Benchmark	Qwen3.8-Flash-Next	Qwen3.8-27B	Qwen3.7-Plus	DeepSeek-V4-Flash	Opus 4.6
SWE-bench Pro Harder engineering	62.5	61.7	55.8	56.0	53.4
SWE-bench Multilingual Multilingual engineering	81.0	73.8	75.8	-	77.5
NL2Repo-Bench Repo-level coding	48.1	42.3	41.1	54.2	47.6
Toolathlon Verified Long-horizon tools	73.5	67.1	50.6	70.3	-
IFBench Instruction following	81.3	79.5	79.1	79.2	62.5
GPQA Diamond Expert science	91.7	89.2	90.3	90.8	91.3
HLE Expert questions	35.9	30.8	34.7	33.8	40.0

It takes five of these seven rows, and the two it loses are worth naming: DeepSeek-V4-Flash is ahead on repo-level code generation, 54.2 to 48.1, and Claude-Opus-4.6 (Max) is ahead on HLE, 40.0 to 35.9. The separate vision table follows the same shape, with wins on AndroidWorld and RealWorldQA and no Claude number published for several rows.

Qwen3.8-Flash-Next hardware requirements

The system requirement to check is memory. Qwen states no hardware target anywhere in the release, so the reference points below are the sizes on disk of the published weight sets, measured from the Hugging Face file listings. Quantized GGUF builds land smaller than all of them; if the format is new to you, start with what GGUF is.

Precision	Source	Size on disk
BF16	Qwen/Qwen3.8-Flash-Next, official	360.0 GB
FP8	Qwen/Qwen3.8-Flash-Next-FP8, official	185.5 GB
NVFP4	RadixArk/Qwen3.8-Flash-Next-NVFP4, community	135.2 GB

Those figures are weights only, so budget the KV cache on top at the 262,144 token context, and more again if you scale toward 1,000,000 tokens with YaRN. Qwen names no accelerator count and no minimum configuration anywhere in the release. It does say that 51B of the parameter count sits in an n-gram embedding that is more amenable to offloading than MoE weights, which it pitches as a way to scale parameters on memory-constrained accelerators, so how much has to stay resident depends on the serving stack you pick.

How to run Qwen3.8-Flash-Next in Atomic Chat

Atomic Chat is a free local app for macOS, Windows and Linux. It includes a Hugging Face model browser and a built-in chat, with no manual llama.cpp build required.

Download Atomic Chat for your platform and open it.
Search for Qwen3.8-Flash-Next in the model browser and open Download Options.
Pick the build that fits the memory you have, then start a chat.

We publish the GGUF builds ourselves as AtomicChat/Qwen3.8-Flash-Next-GGUF. If you would rather serve the original safetensors on a GPU box, Qwen names SGLang, vLLM, TokenSpeed and KTransformers, and ships cookbooks for the first three. For the rest of the lineup, see every Qwen model you can run locally.

Qwen3.8-Flash-Next license

The weights are published under the Qwen Community License 1.0. Hugging Face lists the license as other, with the full terms in the LICENSE file inside the repository rather than a standard open-source identifier, so read that file before you build anything commercial on it.

Get the weights from Hugging Face

huggingface-cli download Qwen/Qwen3.8-Flash-Next
# official FP8 weights, 185.5 GB instead of 360 GB:
huggingface-cli download Qwen/Qwen3.8-Flash-Next-FP8

curl http://localhost:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "Qwen/Qwen3.8-Flash-Next",
    "messages": [{"role": "user", "content": "Plan a refactor of this service."}],
    "temperature": 1.0,
    "top_p": 0.95
  }'

# No GGUF build exists yet, so serve the safetensors with vLLM or SGLang.
# Qwen names SGLang, vLLM, TokenSpeed and KTransformers for deployment.
from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="local")
res = client.chat.completions.create(
    model="Qwen/Qwen3.8-Flash-Next",
    messages=[{"role": "user", "content": "Explain Qwen Sparse Attention."}],
    temperature=1.0,
    top_p=0.95,
)
print(res.choices[0].message.content)

import OpenAI from "openai";

const client = new OpenAI({ baseURL: "http://localhost:8000/v1", apiKey: "local" });
const res = await client.chat.completions.create({
  model: "Qwen/Qwen3.8-Flash-Next",
  messages: [{ role: "user", content: "Draft a migration plan for a Postgres upgrade." }],
  temperature: 1.0,
  top_p: 0.95,
});
console.log(res.choices[0].message.content);

Desktop

macOS

(M1 or better)

Download

Windows

(x64)

Download

Linux

(x86_64)

Download

Frequently asked questions

Qwen3.8-Flash-Next is an experimental preview of the architecture that will underpin Qwen4, published by the Qwen team on 2026-08-24. The language model carries 125B parameters with 6B activated per token, plus 51B of n-gram embedding parameters and 4B of MTP, which the safetensors index reports as 179,999,981,459 parameters in total, about 180B across all weight categories. It is a causal language model with a vision encoder, so it accepts image and video input next to text, and it is tagged image-text-to-text on Hugging Face. Context length is 262,144 tokens natively and extensible to 1,000,000 tokens with YaRN.

Yes. We publish GGUF builds of the model as AtomicChat/Qwen3.8-Flash-Next-GGUF, and Atomic Chat downloads and runs them on your own machine, so prompts and files stay on device. If you would rather serve the original safetensors yourself, Qwen names vLLM, SGLang, TokenSpeed and KTransformers, and the full weights are 360.0 GB in BF16, 185.5 GB in the official FP8 repo and 135.2 GB in the community RadixArk NVFP4 repo. Hugging Face Transformers also loads the repo per the model card note.

Qwen states no accelerator count and no minimum configuration, so go by what the release does publish: file sizes per repo. The BF16 release is 360.0 GB over 131 safetensors shards, the official FP8 release is 185.5 GB over 131 shards, and the community NVFP4 build is 135.2 GB over 206 shards. Those are weights only, so budget the KV cache on top at the native 262,144 token context, and more again if you push toward 1,000,000 tokens with YaRN. Qwen also calls the n-gram embedding, 51B of the parameter count, more amenable to offloading than MoE weights and pitches it as a way to scale parameters on memory-constrained accelerators, so not every weight has to sit in accelerator memory. The model card recommends dedicated serving engines such as SGLang, KTransformers or vLLM for production and high throughput workloads.

The weights are an open-weight release and can be downloaded from Hugging Face, but the license is not Apache 2.0. The repo declares license: other with license_name qwen-community-1.0 and points to the LICENSE file in the repo for the actual terms. Read that LICENSE file yourself and check it against your use case, commercial use included, because the terms are not restated here. If you would rather not host it, Qwen Cloud serves Qwen3.8-Flash, the official version based on Qwen3.8-Flash-Next with 1M context by default and built-in tools.

Qwen Sparse Attention, or QSA, is the attention half of the hybrid design: the Gated DeltaNet and Gated Attention pairing was reworked into Gated DeltaNet plus QSA, and instead of selecting individual tokens QSA operates at the micro-block level, which cuts long-context latency. In this model QSA runs 24 query heads and 2 KV heads at head dimension 256 with rotary dimension 64, an MQA indexer of 4 query heads and 1 shared key head at head dimension 128, and a budget of 512 blocks or 2048 tokens. It sits in a 48 layer stack laid out as 12 repeats of three Gated DeltaNet plus MoE blocks followed by one QSA plus MoE block, with 512 experts of which 10 routed and 1 shared are activated. The other named pieces are Gated Residual with 4 branches and bottleneck rank 320, N-gram Embedding with 20,000,000 bigram and trigram entries indexed at layer 2, and a 1 layer MTP head.