TL;DR: Qwen3.8-Flash-Next (released August 26, 2026) is a 180B-parameter MoE with only 6B active per token — and 51B of those parameters are an n-gram lookup table that can stream from your NVMe drive instead of sitting in RAM. Unsloth’s floor is 75GB of combined RAM+VRAM at 1-bit, and a 128GB Strix Halo box decodes at a measured 22–82 tok/s. No single consumer GPU fits it, and that’s not the point.

	Qwen3.8-Flash-Next (128GB unified box)	Qwen3.8-27B (24GB GPU)	Flash-Next via API
Best for	Best local daily driver above 96GB; agentic work, 260K context	Best model that fits one card	Trying it before touching hardware
Price / Cost	$3,499+ EVO-X2 128GB, or hardware you own	Used RTX 3090 ~$1,286	$0.15/M in, $0.47/M out (OpenRouter)
The catch	75GB memory floor, llama.cpp builds from Aug 27+ only	Loses to Flash-Next on all 9 shared benchmarks	Your prompts leave the building

Honest take: If you own a 24GB card, keep running Qwen3.8-27B and skip this entirely. If you own a 96–128GB unified-memory box, Flash-Next is the best local model you can run today — and its weird architecture (tiny KV cache, SSD-streamable embeddings) is a preview of what local inference looks like in 2027.

Alibaba’s Qwen team shipped Qwen3.8-Flash-Next on August 26, 2026, and the label “Flash” undersells what’s going on. This is an experimental preview of the Qwen4 architecture — llama.cpp literally calls it qwen4exp — and it breaks three assumptions that every VRAM guide on this site, our calculator included, is built on: that all weights must sit in fast memory, that KV cache grows with every layer, and that system RAM is a 10× speed penalty compared to VRAM.

This guide covers what the architecture actually changes, the real memory floors by quantization tier, measured speeds from the first community benchmarks, and the two traps (one Ollama, one llama.cpp) that will eat your first afternoon with it.

What Flash-Next actually is

The official numbers, verified from the QwenLM GitHub repo and the llama.cpp implementation:

Spec	Qwen3.8-Flash-Next
Total parameters	~180B (125B main model + 51B n-gram embeddings + ~4B MTP head)
Active per token	~6B
Architecture	48 layers: 36 Gated DeltaNet + 12 Qwen Sparse Attention (QSA)
Experts	512, top-10 routed + 1 gated shared
Context	262,144 native (1M via YaRN)
Multimodal	Yes — text + vision (stock Qwen3-VL vision tower)
Released	August 26, 2026
License	Qwen Community License 1.0 — not Apache 2.0

Three of those rows deserve unpacking, because they’re what change the hardware math.

The 51B “engram” table. A third of the model’s parameters are per-layer n-gram embeddings — a giant hash table the model looks up rather than computes through. This follows the “scaling embeddings beats scaling experts” line of research (arXiv 2601.21204), and the practical consequence is enormous: lookups are sparse reads, so the table doesn’t need to live in RAM. The llama.cpp implementation streams it via row lookups, and the first Strix Halo deployment kept its 47.7 GiB quantized table on NVMe while decoding at full speed. You read that right — a third of a frontier model’s weights, served from an SSD without wrecking throughput.

Only 12 layers hold KV cache. The 36 DeltaNet layers are linear-attention layers with constant-size state; only the 12 QSA layers keep a cache, and QSA compresses it 4:1 against a 2,048-token budget. Measured result: roughly 6 GiB of KV for a 250K-token context. For comparison, a dense 70B at 128K context wants more KV than most GPUs have VRAM. Long context stops being a memory problem with this design — it becomes a time problem (more on that below).

6B active per token. Decode reads ~6B parameters per token, which is why a 256 GB/s unified-memory box keeps up. This is the same MoE bandwidth math we walked through in why local LLMs got good in 2026, pushed further than any open model yet.

The license: read it before you ship on it

The queue of “just check it’s Apache 2.0” hopes died on contact with the model card. Flash-Next ships under the Qwen Community License 1.0, a new custom license. Per the launch coverage that examined it (CellCog’s scorecard, MarkTechPost): commercial use, modification, distribution, and self-hosting are allowed; products above 100M monthly active users or US$20M monthly revenue must prominently display the model name; and running a Model-as-a-Service or “AI work assistant” business on it requires a separate license from Qwen.

For a home lab, none of that bites — run it, fine-tune it, build on it. But if your company standardized on Apache-2.0-only models (Qwen3.6 qualified; this doesn’t), Flash-Next needs a legal review before it touches production. Same pattern as GLM-5.3’s revenue-threshold license — 2026’s frontier drops are converging on “free until you’re big.”

Memory floors: what 75GB actually buys

Unsloth published the combined RAM+VRAM requirements per quantization tier in their official docs:

Quant tier	Combined RAM+VRAM needed	Who can run it
1-bit	~75GB	96GB unified boxes, 64GB RAM + 24GB GPU
2-bit	~79GB	Same, comfortably on 96GB
3-bit	~90GB	96GB tight, 128GB comfortable
4-bit	~112GB	128GB unified, 128GB RAM towers

Two footnotes that matter more than the table. First, the 4-bit download is 92.9GB, but per the community VRAM thread on Unsloth’s GGUF repo, only about 54.5GB of it must stay resident — the engram table portion can be offloaded to storage. A fast NVMe drive is effectively part of your memory hierarchy for this model. Second, because only ~6B parameters activate per token, the usual “CPU inference is 10× slower” rule collapses: Unsloth’s own guidance is that RAM vs. VRAM placement makes unusually little difference here. A 128GB DDR5 tower without any GPU is a legitimate Flash-Next machine — although at 2026 DRAM crisis prices, 128GB of DDR5 is its own financial event.

What this means per hardware tier:

• 24GB GPU (used RTX 3090/4090): does not fit, full stop. Even the 1-bit tier wants 75GB. Partial offload works mechanically but you’re really running a RAM-resident model with a 24GB accelerator attached. Keep Qwen3.8-27B on these cards.
• 96GB tier (best local LLM for 96GB): 1-bit and 2-bit fit; 3-bit is on the edge.
• 128GB unified (Strix Halo, 128GB tier guide): the sweet spot. The measured Strix Halo deployment below ran a ~4.78-bit weight quant with ~98.5 GiB resident plus the 47.7 GiB engram table streaming from SSD; the daily.dev test series on the same class of machine reported peak memory up to 111GB at 4-bit.

Measured speed: the first real numbers

The best public data so far is a documented deployment on a single AMD Ryzen AI MAX+ 395 (Strix Halo, gfx1151, 128GB unified memory) — the abliter8-ai GitHub repo publishes the full methodology, median-of-5 decode numbers, and reproduction scripts:

Configuration	Prose	Code	Structured output
Reference HIP build, no speculation	22.1 tok/s	21.9 tok/s	22.1 tok/s
Vulkan + MTP speculation	22.3 tok/s	30.0 tok/s	33.9 tok/s
Tuned HIP + MTP (q8_0 KV)	21.9 tok/s	66.0 tok/s	55.3 tok/s
Tuned HIP + MTP (f16 KV)	23.1 tok/s	82.0 tok/s	41.7 tok/s

The spread is the story. Flash-Next ships a multi-token-prediction (MTP) draft head — the same speculative decoding idea, built into the model — and its acceptance rate depends entirely on how predictable your output is: 0.93 for structured output, 0.88 for code, 0.59 for prose. Writing code, the box nearly 4בd its baseline. Writing essays, MTP bought almost nothing. If your workload is agentic coding, the effective speed on a $3,500 mini PC is in RTX-class territory; if it’s prose, plan around ~22 tok/s (still comfortably above reading speed).

Prefill on the tuned build held nearly flat at 290→249 tok/s across the first 48K tokens, versus the reference build’s decay from 244 tok/s at 8K to 87 tok/s at 200K. And the tiny KV cache made a 201,647-token prompt work on a mini PC — with a catch: 17.3 minutes to first token. That’s the long-context trade this architecture makes. The memory wall is gone; the prefill clock is not. For genuinely huge one-shot prompts, renting an 80GB datacenter card on RunPod for an hour is still the sane path.

No verified RTX 3090/4090 offload benchmarks have been published yet — the Unsloth speed thread has multi-4090 owners actively testing, and early GGUF exports reportedly predate the MTP-head export (so llama.cpp users saw decode decay that re-exported quants fix). We’ll update when measured NVIDIA numbers land; until then, treat any Flash-Next-on-RTX tok/s figure you see as unverified.

The two traps: Ollama’s MLX-only tag and the qwen4exp error

Trap one — the Ollama library tag is Mac-only. ollama.com/library/qwen3.8-flash-next exists, which makes Linux and Windows users think ollama pull is the path. It isn’t: the tags (e.g. :125b-mlx) run on Ollama’s MLX engine — Apple Silicon only, the engine that went stable in Ollama v0.30. On a CUDA box the standard GGUF engine can’t load the architecture yet. If you’re on a Mac with 96GB+ unified memory, Ollama is the easy button. Everyone else uses llama.cpp directly.

Trap two — your llama.cpp is too old. Support for qwen4exp merged into mainline llama.cpp on August 27, 2026 (PR #27742). Any build older than that fails like this:

$ llama-server -m Qwen3.8-Flash-Next-Q2_K.gguf --ctx-size 32768
llama_model_load: error loading model: unknown model architecture: 'qwen4exp'
llama_load_model_from_file: failed to load model

The fix is the same as every new-architecture drop — update the binary, not the model file. We covered the general pattern in the unknown-architecture fix guide; the short version is that LM Studio and Ollama bundle their own engine copies, so “I updated the app” doesn’t always mean “the engine understands qwen4exp.” Check the build date, not the app version. The PR notes two more edge cases worth knowing: CUDA hits a grid-dimension overflow at the full native 262,144 context (practical ceiling 261,888 — set --ctx-size accordingly), and QSA output can diverge slightly from dense attention on ~3% of positions in prompts past the 8K sparse-attention budget, by design.

Is it actually better than Qwen3.8-27B?

On Qwen’s own numbers, yes — everywhere. Flash-Next beats its dense 27B sibling on all nine shared benchmarks tracked at launch, by an average of 4.19 points, with the biggest gaps in agentic work: DeepSWE 1.1 jumps from 42.2 (27B) to 58.7, SWE-bench Pro edges from 61.7 to 62.5, and SWE-bench Multilingual hits 81.0 (per DataCamp’s launch analysis and the aggregated scorecards). These are vendor benchmarks with no independent replication yet — the usual week-one caveat applies.

But the benchmark table isn’t the real comparison for a buyer. This is:

	Qwen3.8-27B	Qwen3.8-Flash-Next
Fits a used $1,286 RTX 3090	Yes (16.8GB Q4)	No (75GB floor)
Measured speed	~41 tok/s (3090, day-one bench)	22–82 tok/s (Strix Halo 128GB)
Long-context cost	KV cache grows normally	~6 GiB KV at 250K tokens
License	Apache 2.0 lineage	Qwen Community License 1.0

Different machines, different winners. The 27B remains the best thing you can put on one 24GB card (our hardware guide), and it’s the one you can fine-tune on a 4090 with Unsloth. Flash-Next is what the 96–128GB crowd has been waiting for: until now their options above the 24GB class were 1–2-bit squeezes of models built for 8×H100 racks. This is the first frontier-quality 2026 release designed to be comfortable at their tier.

What to buy (and what not to)

Own a 24GB card? Buy nothing. A used RTX 3090 still runs the better-per-dollar stack ($1,286 market average in early September 2026, fair range $1,222–$1,328 across 343 listings per ResalePrices — our value-king writeup holds), and Flash-Next doesn’t change that tier at all.

Shopping the 128GB unified tier? The GMKtec EVO-X2 128GB is the proven Flash-Next box — it’s the exact hardware class in the measured benchmarks above — but the DRAM crisis moved it from its $1,999 launch to $3,499 (1TB) / $3,649 (2TB). Whether that’s worth it depends on the MTP question: if your workload is code and structured/agentic output, you’re buying 55–82 tok/s on a 180B-class model at ~140W. If it’s prose, you’re buying 23 tok/s, and the rent-vs-buy math tilts hard toward the API at $0.15/M input, $0.47/M output (OpenRouter, September 2026). Our EVO-X2 review covers the box itself.

On a Mac? A Mac Studio with 96GB+ unified memory is the lowest-friction path — it’s the one platform where the official Ollama tag just works. No measured Apple Silicon tok/s numbers have been published yet; given the 6B-active math they should land near or above the Strix Halo baseline, but that’s an inference, not a benchmark.

Building a CPU tower? Flash-Next is the strongest argument yet for the RAM-inference builds we covered in CPU vs GPU for local LLMs — 6B active parameters and an SSD-streamable engram table were practically designed for a 128GB DDR5 machine with a fast NVMe drive. Just price the RAM first; the crisis hasn’t blinked.

If you write code against local models, Flash-Next’s 262K context and MTP-accelerated structured output make it a serious local backend for coding agents at the 128GB tier; for the pure self-hosting angle, aifoss.dev tracks the FOSS stack around it.

FAQ

Can I run Qwen3.8-Flash-Next on an RTX 4090 or RTX 5090? Not as the primary device. Even 1-bit needs ~75GB of combined memory, so a 24–32GB card is at most an accelerator for a RAM-resident deployment. No verified single-RTX benchmarks exist yet.

Why is the download 92.9GB but the memory requirement lower? About half the download is the 51B n-gram embedding table, which the runtime can look up from NVMe instead of loading into RAM. Roughly 54.5GB of the 4-bit build must actually stay resident, per the Unsloth GGUF discussion.

Does ollama pull qwen3.8-flash-next work on Linux with an NVIDIA GPU? No — the library tags run on Ollama’s MLX (Apple Silicon) engine only, as of early September 2026. Use llama.cpp built on or after August 27, 2026.

Is the 1M-token context real? Native context is 262,144 tokens; 1M is a YaRN extension. And mind the clock, not the memory: a 200K prompt took 17.3 minutes to first token on the measured Strix Halo box, even though its KV cache fit in ~6 GiB.

Is this Qwen4? Not officially — it’s an experimental preview of the architecture (llama.cpp names it qwen4exp). Treat it as a working glimpse of what the Qwen4 family will look like: hybrid linear attention, huge embeddings, small active core.

Recommended Gear

• GMKtec EVO-X2 (Ryzen AI Max+ 395, 128GB) — the measured Flash-Next box
• Mac Studio M4 Max 128GB — easiest path via Ollama MLX
• Used RTX 3090 — still the right buy below 24GB; runs Qwen3.8-27B instead

Sources

• Qwen3.8-Flash-Next official repository — QwenLM / GitHub
• Alibaba’s Qwen Team Releases Qwen3.8-Flash-Next — MarkTechPost
• model: add Qwen3.8-Flash-Next (qwen4exp), PR #27742 — ggml-org/llama.cpp
• Qwen3.8-Flash-Next on a single AMD Strix Halo — abliter8-ai / GitHub
• Qwen3.8-Flash-Next: How to Run Locally — Unsloth Documentation
• How much VRAM do you need to run this model? — unsloth/Qwen3.8-Flash-Next-GGUF discussion
• Share your model speed here — unsloth/Qwen3.8-Flash-Next-GGUF discussion
• qwen3.8-flash-next — Ollama library
• Qwen3.8-Flash-Next Is Out: Confirmed Specs, License, and the Leak Scorecard — CellCog
• Qwen3.8-Flash-Next: Features, Benchmarks, and Pricing — DataCamp
• Qwen3.8 Flash — API Pricing & Providers — OpenRouter
• Scaling Embeddings Outperforms Scaling Experts in Language Models — arXiv
• RTX 3090 Used GPU Price & Fair Asking Range — ResalePrices
• GMKtec EVO-X2 with 128GB RAM debuts at $3,500 — VideoCardz

Last updated September 2, 2026. Prices and specs change; verify current rates before purchasing.