Qwen3.8-Flash-Next

On 26 August 2026 Alibaba shipped two things with almost the same name. Qwen3.8-Flash is a hosted model you rent by the token. Qwen3.8-Flash-Next is a 360GB pile of weights you can download right now. Only one of them is open, the names do not tell you which, and the open one is not Apache 2.0. Here is what actually landed, what the license costs you, and what it takes to run 6 billion active parameters on hardware you own.

Qwen3.8-Flash and Qwen3.8-Flash-Next are not the same model

Qwen3.8-Flash is the served product on QwenCloud. It runs a 1M-token context by default, ships with built-in tools, and costs $0.15 per million input tokens and $0.47 per million output. It is also on OpenRouter, though with a single provider (Alibaba Cloud International), so there is no failover if that endpoint has a bad day. There are no weights for it and there will not be.

Qwen3.8-Flash-Next is the open release. Qwen describes it as "an early preview of the architecture used in Qwen4," which is an unusually honest framing: this is an architecture demo the community gets to poke at before the real Qwen4 family is built on top of it. If you have read our Qwen 3.6 writeup, this split will look familiar. Alibaba has now done the open-small, closed-large dance three generations running, and each time the headlines conflate the two.

What actually shipped

The parameter count depends on what you are counting. The Mixture-of-Experts backbone is 125B. On top of that sit 51B of N-gram embeddings and a roughly 4B multi-token-prediction module, which is where the "180B" figure some outlets print comes from. That number is disk size, not the model doing the reasoning. Active parameters per token: 6B. That is the headline.

From the published config: 48 layers, hidden size 2560, a 248,320-token vocabulary, 512 experts with 10 routed plus 1 shared per token. Attention is a hybrid on a 4-layer cycle. Three of every four layers use Gated DeltaNet, a linear-attention design that scales cheaply with context length. The fourth uses Qwen Sparse Attention with a 2048-entry indexer budget. Native context is 262,144 tokens, stretching to 1M with YaRN scaling. It takes text, images, and video in, and emits text.

Two more pieces are new. Gated Residual splits the residual stream into four branches. The N-gram embedding table is a 20-million-entry lookup over 3-grams, which is the 51B, and it is designed to sit in host RAM rather than VRAM. Training used the Muon optimizer, and Qwen claims the whole run cost about one ninth of what Qwen3.7-Plus cost. They also claim Qwen Sparse Attention delivers up to 7.6x prefill and 4.9x decoding speedups over full attention, and 8.6x the prefill throughput of Qwen3.7-Plus at 1M context with a 90% prefix-cache hit rate. All vendor numbers, none reproduced independently.

Weights come in two flavors: BF16 at 360GB across 131 shards, and FP8 at 186GB. The FP8 build uses fine-grained block-128 quantization and deliberately leaves the embeddings, the gated-residual mixer, the linear-attention projections, the MoE gates, and the shared experts in higher precision. Only the routed experts are FP8.

The license is not Apache 2.0

This is the part worth reading before you plan a product around it. Flash-Next ships under the Qwen Community License 1.0. The grant is MIT-shaped (use, copy, modify, merge, publish, distribute, sublicense, sell, deploy, host, fine-tune) with two conditions attached.

Condition one triggers at 100 million monthly active users or $20 million in monthly revenue: above that, you must display the model name prominently in your product's interface. That is an attribution duty, not a payment. Do not let anyone tell you Qwen added a revenue share, because they did not.

Condition two is the one with teeth. If you or any affiliate runs a Model-as-a-Service or an AI Work Assistant business, you need a separate commercial license from Qwen before using the model commercially at all. No size threshold. Qwen defines Model-as-a-Service as giving third parties access to inference or fine-tuning in a way that lets them control inputs, parameters, or training data, which is to say: any inference API. AI Work Assistant means a product primarily built for AI-assisted coding or office productivity. Internal use is carved out, as long as you are not exposing the model, its outputs, or its capabilities to anyone outside your company.

So: fine-tune it for your own internal code review, no problem. Wrap it in an API and sell access, or build a coding assistant on it, and you are emailing Qwen's licensing desk first. For a lot of the small teams who read this site, that is the difference between a usable base model and a dead end.

The pattern across the Qwen3.8 family is hard to miss. The dense 27B is straight Apache 2.0. Flash-Next carries the Community License. The 2.4T-A95B weights carry a separate Qwen3.8-Max license with its own conditions. The bigger the model, the tighter the terms.

Benchmarks (Qwen-reported)

Every row below is from Qwen's own launch materials. We have limited the table to figures the Hugging Face model card independently restates, so at least the vendor is saying the same thing in two places. The comparison columns are Qwen's chosen opponents, which is its own kind of editorial decision.

Vendor-reported, not independently reproduced. The central claim, that a 125B-A6B model beats a much larger predecessor at roughly one ninth the training cost, rests entirely on Qwen's own evaluation.

The one properly independent read comes from Artificial Analysis, which scores Flash-Next at 56 on its Intelligence Index v4.1.1, ranking it 5th of 112 open-weight models against a median of 29. Measured output speed is 66 tokens per second with a 2.74s time to first token. They also flag it as "very verbose": about 200 million output tokens across their eval suite versus a 110 million median. At $0.47 per million output tokens on the hosted endpoint, verbosity is a line item, not a personality quirk.

Run it today

Qwen documents transformers, vLLM, SGLang, and TokenSpeed. Ollama has an official library entry. Here are the commands that matter:

# vLLM, tensor parallel across 4 GPUs, 256K context
vllm serve Qwen/Qwen3.8-Flash-Next --port 8000 --tensor-parallel-size 4 \
  --max-model-len 262144 --reasoning-parser qwen3 \
  --enable-auto-tool-choice --tool-call-parser qwen3_coder

# SGLang, same shape
sglang serve --model-path Qwen/Qwen3.8-Flash-Next --port 8000 --tp-size 4 \
  --context-length 262144 --reasoning-parser qwen3 --tool-call-parser qwen3_coder

# 4x H100 80GB: push the 51B N-gram table into host RAM
VLLM_PLE_CPU_OFFLOAD=1 vllm serve Qwen/Qwen3.8-Flash-Next-FP8 \
  --tensor-parallel-size 4 --moe-backend triton \
  --gpu-memory-utilization 0.85 --max-num-seqs 256

# Ollama. Read the tag: this one runs on the MLX engine, Apple Silicon only.
ollama run qwen3.8-flash-next:125b-mlx

Thinking mode is on by default at xhigh reasoning effort; drop it with --chat-template-kwargs '{"reasoning_effort":"medium"}'. For sampling, Qwen suggests temperature 1.0, top_p 0.95, top_k 20 in thinking mode.

What it actually takes to run

In the datacenter, the FP8 checkpoint is 173 GiB and two-way tensor parallel is the validated minimum on GB300, at roughly 86 GiB per GPU. BF16 is 335 GiB and wants about 190 GiB per GPU at TP2. Locally, the Unsloth quant ladder is the useful reference:

Note the floor: even the 1-bit build needs 75GB, because the N-gram and embedding layers cannot go below 4-bit without wrecking the model. Their access pattern is effectively random, so aggressive quantization there does real damage. No single 24GB consumer GPU runs this at any quantization, and pretending otherwise wastes your afternoon.

What does work: a Mac Studio M3 Ultra with 256GB reportedly gets about 15.5 tokens per second at Q4_K_M. One developer got a 104GB build running on a 48GB Mac at roughly 12 tok/s using expert offloading and SSD streaming, and a commenter trying the same trick from a USB disk got 0.5 tok/s. Disk bandwidth, not compute, is the wall. If you want to compare runtimes before committing, our inference server comparison covers the trade-offs.

The Flash tier is crowded

Three labs shipped a "Flash" class model within about two weeks of each other:

There is no benchmark all three were measured on. DeepSeek reported its own suite, Z.ai reported Terminal-Bench 2.1 and DeepSWE, Qwen reported SWE-bench Pro and CoWorkBench. Any ranking you see across the three is somebody's apples-to-oranges arithmetic.

What is comparable is the architecture. Flash-Next activates 6B parameters per token against 13B and 18B for its rivals. If the quality holds, that is less compute per token than either competitor, which is the whole point of the exercise.

Limitations and gotchas

• It is a preview, and Qwen says so. The architecture is the deliverable; the model is intentionally under-trained relative to what Qwen4 will be. The community consensus is that GLM-5.3 Flash is the finished thing to run in production today.
• qwen4_exp is a brand-new architecture. Any llama.cpp, Ollama, or MLX build from before support landed will not load these checkpoints at all, and the error will not be obvious.
• Plain TP8 is incompatible with the FP8 checkpoint on 8x H200; you need expert parallel (TEP8) instead. This has already caught early adopters.
• Pipeline parallelism is unsupported. Tensor or expert parallel only.
• Multi-token prediction lowers request throughput 8 to 36% on H100, and vLLM ships with it off by default.
• The N-gram host-RAM offload, the thing that makes the design memory-friendly, is NVIDIA-only. Mac and AMD users get the 51B table but not the trick that makes it cheap.
• It loses to DeepSeek V4 Flash on NL2Repo-Bench (48.1 against 54.2) in Qwen's own table, and trails Claude Opus 4.6 on HLE (35.9 against 40.0).
• Verbosity costs money on hosted inference and patience locally. Turn the reasoning effort down for anything that is not genuinely hard.

Who should use it

If you run a workstation with 96GB or more of unified memory or host RAM, Flash-Next is the most interesting thing you can download this month, and the 4-bit build at 92.3% top-1% accuracy is a real working model rather than a curiosity. If you are an architecture nerd, the config alone is worth an afternoon: linear attention at a 3:1 ratio, a 20-million-entry N-gram table, and gated residuals are all choices you can copy.

If you are building a product that serves inference to anyone outside your company, read condition two of the license before you write any code. And if you just want the best open coding model to run today, GLM-5.3 Flash is the safer bet, with Qwen3.5 still holding up for anyone who needs Apache 2.0 terms without argument.

Sources and further reading

• Qwen3.8-Flash-Next on GitHub
• Model card and BF16 weights on Hugging Face
• FP8 checkpoint on Hugging Face
• Qwen Community License 1.0, full text
• vLLM deployment recipe and hardware matrix
• Unsloth quantization ladder and llama.cpp build notes
• Artificial Analysis independent evaluation
• Ollama library entry (MLX tags)
• QwenCloud pricing for the hosted Qwen3.8-Flash

Tested on: not independently tested. Architecture figures come from the published config.json and README; benchmark numbers are Qwen-reported except the Artificial Analysis index, which is independent. Memory and throughput figures are from vLLM's recipe, Unsloth's quantization notes, and community reports, not from our own hardware.
Date checked: 2026-09-04