Qwen3.8-Flash-Next Hardware Requirements for Self-Hosting

Qwen3.8-Flash-Next self-hosting comes down to three numbers: 125B total parameters, 6B active per token, and a 51B N-gram embedding table that does not need to live on the GPU. Alibaba's Qwen team released the open weights on August 26, 2026, describing the model as an early preview of the architecture that will underpin Qwen4. The FP8 checkpoint is 172.78 GiB and the BF16 checkpoint is 335.28 GiB. Unsloth's GGUF quantizations land at 111 GB for UD-Q4_K_XL and 78.9 GB for UD-Q2_K_XL. In hardware terms, a two-GPU workstation serves a 4-bit build, a four-GPU node serves FP8 with tensor parallelism of four, and the N-gram table sits in system RAM. The license is the Qwen Community License 1.0, not Apache 2.0, which is the one detail a regulated buyer must resolve before anything is racked. Here is how to size it.

What is Qwen3.8-Flash-Next?

Attribute	Qwen3.8-Flash-Next
Developer	Alibaba Qwen team
Released	August 26, 2026
Main model	125B total parameters, mixture-of-experts, 6B activated per token
Extra components	51B N-gram embedding table (offloadable to host RAM), 4B multi-token-prediction (MTP) head
Layers and experts	48 layers; 512 experts, 10 routed plus 1 shared active; hidden size 2560
Attention	Hybrid: Gated DeltaNet (linear) in 3 of every 4 layers, Qwen Sparse Attention (QSA) in the 4th
Modalities	Text, image, and video in; text out
Context	262,144 tokens native; extensible to 1,000,000 with YaRN
License	Qwen Community License 1.0 (custom, not Apache 2.0)
Weights	Hugging Face: Qwen/Qwen3.8-Flash-Next (BF16), Qwen/Qwen3.8-Flash-Next-FP8; community GGUF at unsloth/Qwen3.8-Flash-Next-GGUF
Positioning	"An early preview of the architecture that will underpin Qwen4"

Two design choices set this model apart from every other open-weight release of August 2026. First, the hybrid attention stack. Three of every four layers use Gated DeltaNet, a linear-attention mechanism whose memory cost does not grow with sequence length the way standard attention does. The fourth layer uses Qwen Sparse Attention. KV-cache growth at long context is therefore far gentler than in a conventional transformer of the same size, which matters when the native window is 262K tokens.

Second, the N-gram embedding table. A 20,000,000-entry bigram and trigram embedding sits at layer 2 and accounts for 51B parameters on its own. Qwen states this table "can be offloaded to host memory and overlapped with model computation." That is a new axis for self-hosting: capacity you buy as DDR5 rather than HBM. The 4B MTP head supports speculative decoding, which raises tokens per second on the same silicon.

The model card also lists a Gated Residual design with four residual branches and training with the Muon optimizer. Those details make this a Qwen4 architecture preview rather than a Qwen3 refresh, so serving configs and evaluation harnesses built for it should carry forward.

How big is each checkpoint?

Memory sizing starts with the files you download. These figures come from the official Hugging Face repositories and the Unsloth GGUF listing.

Format	Source	Size on disk
BF16	Qwen/Qwen3.8-Flash-Next	335.28 GiB
FP8	Qwen/Qwen3.8-Flash-Next-FP8	172.78 GiB
GGUF BF16	unsloth/Qwen3.8-Flash-Next-GGUF	354 GB
GGUF Q8_0	unsloth/Qwen3.8-Flash-Next-GGUF	192 GB
GGUF UD-Q4_K_XL	unsloth/Qwen3.8-Flash-Next-GGUF	111 GB
GGUF UD-Q2_K_XL	unsloth/Qwen3.8-Flash-Next-GGUF	78.9 GB
GGUF UD-IQ1_S	unsloth/Qwen3.8-Flash-Next-GGUF	72.5 GB

Two notes on reading that table. The checkpoint sizes cover the main model, the N-gram table, and the MTP head together, so once the N-gram table is offloaded to host memory, GPU-resident weight memory drops well below the file size. And every figure is on-disk weight size only. Add KV cache and serving overhead on top, and more if you serve long contexts to many users at once.

Which hardware tier fits your deployment?

Qwen's own serving examples for vLLM and SGLang use a tensor-parallel size of four, and the GitHub README states that TP2 is the minimum validated FP8 configuration on GB300. Combining those official data points with the checkpoint sizes gives three practical tiers.

Tier	Precision	GPU-resident weights	Typical configuration	System RAM role	Fits
Workstation	UD-Q4_K_XL GGUF (111 GB)	~111 GB plus KV cache	2 high-memory datacenter GPUs, llama.cpp or KTransformers	Hosts the N-gram table and any offloaded experts	Pilot, department, single-team agent workloads
Validated minimum FP8	FP8 (172.78 GiB)	~173 GiB plus KV cache, split across 2 GPUs	2× GB300, TP2 (the minimum Qwen validated)	Hosts the N-gram table	Production for a small user population
Production node	FP8 (172.78 GiB)	~173 GiB plus KV cache, split across 4 GPUs	4-GPU node, vLLM or SGLang with --tensor-parallel-size 4	Hosts the N-gram table	Production with real concurrency and long contexts

Three sizing rules follow from the architecture.

1. Budget system RAM as a first-class line item. The 51B N-gram table is designed to live in host memory and overlap with compute. A node with 512 GB or more of DDR5 is cheap next to the GPUs and unlocks the offload path. Confirm the offload works with your chosen framework before purchase; Qwen lists SGLang, vLLM, TokenSpeed, KTransformers, llama.cpp, and Transformers as supported.
2. 6B active parameters means decode is fast on modest compute. Per-token FLOPs resemble a 6B dense model. The bottleneck is memory capacity and bandwidth, not raw compute, so prioritize GPU memory size over clock speed when choosing between two cards at the same price.
3. Long context is cheaper here than on a standard transformer, but not free. Gated DeltaNet in three of four layers keeps the KV footprint manageable at 262K. If you plan to run the 1M YaRN extension in production, test it on your real documents first; the model card lists 262,144 as the native window and 1M as an extension.

Third-party reports say the model runs locally in about 75 GB of RAM via quantization. That claim comes from press and analyst blogs, not the model card. The 72.5 GB UD-IQ1_S file is consistent with it, but 1-bit quantization carries a quality cost that must be evaluated per workload first.

How does it benchmark?

These figures are from the Qwen model card and the FP8 repository card. They are vendor-reported and have not been independently reproduced by us.

Benchmark	Qwen3.8-Flash-Next	Comparison on the card
SWE-bench Pro	62.5
DeepSWE 1.1	58.7	DeepSeek-V4-Flash: 54.4
GPQA Diamond	91.7
LiveCodeBench v6	91.9
CoWorkBench	73.9	DeepSeek-V4-Flash: 45.1
AndroidWorld	84.5
OSWorld 2.0 (binary)	19.4
MathVision	95.7
ClawEval-MM (Pass@3)	64.4
JobBench	55.7

The pattern is a model that punches far above its 6B active parameter count on coding and agentic work, and that brings native vision to the table with a strong MathVision score. For a healthcare deployment, the vision path is the practical hook: scanned referrals, faxed lab reports, and imaging notes go straight into the same model that drafts the summary, with no separate OCR stage and no second vendor. Every one of those pages stays on hardware you control.

What does the Qwen Community License mean for procurement?

Qwen3.8-Flash-Next is tagged qwen-community-1.0 on Hugging Face. That is the Qwen Community License 1.0, and it is not Apache 2.0. Qwen's dense sibling, Qwen3.8-27B, does ship under Apache 2.0, so a buyer who assumes the whole Qwen3.8 family carries the same permissive terms will get this one wrong.

We have not verified the exact clauses of the Qwen Community License 1.0 for this article. Do not rely on a summary, including this one. Your procurement and legal teams must read the full LICENSE file in the model repository before any commercial or regulated deployment, and specifically confirm three things: whether redistribution of derivatives is permitted, whether any usage or revenue thresholds trigger additional obligations, and whether any geographic restrictions apply. Until that review is done, the model belongs in a lab, not a production rack.

How does it compare with GLM-5.3-Flash and Qwen3.8-27B?

Regulated on-premise buyers in September 2026 are choosing among three "fits on a small box" models. They sit at different points on the memory, capability, and license axes.

	Qwen3.8-Flash-Next	GLM-5.3-Flash	Qwen3.8-27B
Developer	Alibaba Qwen	Z.ai (Zhipu)	Alibaba Qwen
Released	Aug 26, 2026	Aug 25/26, 2026	mid-Aug 2026
Parameters	125B MoE, 6B active (+51B N-gram, +4B MTP)	320B MoE, 18B active	27B dense
Multimodal	Yes (text, image, video in)	Yes (text, image, video, visual documents)	Yes
Context	262K native, 1M with YaRN	1M	262K native, 1M
License	Qwen Community 1.0 (custom)	MIT	Apache 2.0
4-bit GGUF size	111 GB (UD-Q4_K_XL)	200 GB (UD-Q4_K_XL)	Fits a single 24 to 32 GB GPU class
FP8 weights	172.78 GiB	~306 GiB
SWE-bench Pro	62.5		61.7
DeepSWE 1.1	58.7	63.4
GPQA Diamond	91.7		89.2
Terminal-Bench 2.1		84.3	73.0

The decision logic is straightforward.

• License review must be trivial. Choose GLM-5.3-Flash. Plain MIT, no custom clauses, and the strongest Terminal-Bench 2.1 and DeepSWE numbers of the three. The cost is memory: roughly 200 GB at 4-bit and about 306 GiB at FP8, which pushes you toward a four-GPU node where Qwen3.8-Flash-Next fits on two.
• Hardware budget is a two-GPU workstation and you need vision. Choose Qwen3.8-Flash-Next, subject to the license review above. The 111 GB 4-bit build and the host-RAM N-gram offload are what make the small footprint possible.
• You want Apache 2.0 and the smallest possible box. Choose Qwen3.8-27B. Dense, multimodal, Apache 2.0, and close behind Flash-Next on SWE-bench Pro and GPQA Diamond. It gives up the MoE efficiency and the 1M context headroom that the larger models offer.

For the full portfolio view, including where the 750B-class models belong, see our GLM-5.2 GPU requirements guide and the Qwen model family page.

Why is this a sovereign deployment, not just a cheap one?

Qwen3.8-Flash-Next has a hosted twin, Qwen3.8-Flash, served on QwenCloud, Qwen Studio, and QwenWork. That twin is irrelevant to a sovereign buyer. The Next weights are static files. Once they are on your storage, inference runs entirely on your hardware with no Alibaba server in the loop, no API key, no telemetry, and no dependency on any foreign vendor's uptime or policy.

That is the whole point of an on-premise LLM deployment for a regulated organization. Patient records, privileged client files, and controlled technical data never leave the building. The model version is pinned, so an evaluation you ran in September is still valid in March. And a change in export policy, pricing, or corporate strategy on the other side of the world cannot reach into your rack. The one thing a static file cannot do is rewrite its own license, which is why the license review must happen before the download becomes a deployment.

The bottom line

Qwen3.8-Flash-Next is the smallest hardware footprint of any frontier-adjacent open-weight model released in August 2026: a 111 GB 4-bit build on two GPUs, FP8 on a two-to-four GPU node, and a 51B N-gram table that lives in system RAM instead of VRAM. It is multimodal, 262K-native, and previews the Qwen4 architecture, so the engineering carries forward. The single blocker for a regulated buyer is the Qwen Community License 1.0. Read it, clear it, and then size the box.