Qwen3.8-Flash-Next VRAM: FP8 weights alone are 185.5 GB

Qwen 3.8 Flash Next VRAM needs are large: the model card gives no figure, but the weights alone are about 360 GB in BF16 and 185.5 GB in the FP8 version, before any memory for the context. That comes from the file sizes of the two repositories on Hugging Face, which we checked on October 31, 2026. It is a mixture-of-experts model with vision, and the weights are public.

Qwen's own description is "an experimental preview of the architecture that will underpin Qwen4." So this is not a laptop model, and it is not the 27B model that most people run at home.

How much VRAM Qwen3.8-Flash-Next needs

The model card does not list a VRAM figure, a GPU count or a recommended card. It only says that for production or high-throughput use, a serving engine such as SGLang, KTransformers or vLLM is strongly recommended.

What the Hub does show is the size of the files. VRAM is the memory on your GPUs, and the weights have to fit in it (or be split across several cards) before the model can answer anything.

The FP8 card says it uses fine-grained FP8 quantization with a block size of 128, and that its metrics are "nearly identical" to the original model. It gives no benchmark numbers to back that up.

Two points follow from the arithmetic, and they are our reading, not Qwen's. First, 185.5 GB is more than two 80 GB GPUs hold, so even the FP8 build needs a multi-GPU server. Second, the cache that holds the conversation so far, and the memory the serving engine uses, come on top of the weights. How much depends on your context length and batch size, and Qwen does not publish a number.

If you want something that fits on one consumer card, our guide to running Qwen 3.8 locally covers the 27B model, which is a different release.

Is Qwen3.8-Flash-Next a mixture-of-experts model

Yes. A mixture-of-experts model has many small expert networks and uses only a few of them for each token. The card lists:

• 125B total parameters and 6B active for each token.
• 512 experts, with 10 routed and 1 shared expert used per token.
• Another 51B parameters in an n-gram embedding table and 4B for multi-token prediction. The Hub shows about 180B parameters in all.
• 48 layers that mix two kinds of attention: Gated DeltaNet, a linear attention that stays cheap on long inputs, and Qwen Sparse Attention.

The small active count makes the model fast for its size. It does not shrink the weights you must store. All of them have to be loaded, which is why the download is 185 GB or more.

Does it have vision

Yes. The card calls it a causal language model with a vision encoder, and the page takes text, images and video. The native context is 262,144 tokens, and it can be stretched to 1,000,000 tokens with YaRN, a method for extending context. The card warns that static YaRN can hurt short-text results, so turn it on only when you need it.

Thinking is on by default. You can switch it off with enable_thinking, and reasoning_effort takes xhigh (the default), medium or low.

Is Qwen3.8-Flash-Next open source

The weights are public on Hugging Face, and the license tag reads qwen-community-1.0. We did not read the terms of that license, so we can't say what it allows. It is not the Apache 2.0 license that the Qwen3.8-27B model uses, so check the license file in the repository before you build a product on it.

The repository was created on August 24, 2026, and the card lists the release as August 2026. Qwen says the hosted Qwen3.8-Flash, built on this model, adds production features such as a 1M-token context by default and built-in tools.

How Qwen says it performs

These are Qwen's own numbers, from the card, and not independent tests. Qwen compares the model with its 27B model, Qwen3.7-Plus, DeepSeek-V4-Flash-0731 and Claude Opus 4.6.

It does not win everywhere. DeepSeek-V4-Flash scores higher on NL2Repo-Bench (54.2 against 48.1), and Opus 4.6 scores higher on HLE (40.0 against 35.9). The gap to the dense 27B model is small on most rows, so unless you need the extra margin, the smaller model is far cheaper to run.

How to serve it

The card gives these starting commands:

pip install vllm
vllm serve "Qwen/Qwen3.8-Flash-Next"

pip install sglang
python3 -m sglang.launch_server --model-path "Qwen/Qwen3.8-Flash-Next" --host 0.0.0.0 --port 30000

Swap in Qwen/Qwen3.8-Flash-Next-FP8 for the smaller build. We did not run these commands, and the card shows no tensor-parallel setting, which a multi-GPU machine will need. Qwen also points to its blog and a technical report on the architecture, which we have not read in full. The report is the place to look for memory figures that the card leaves out.