Model reference · open weights

Qwen3.8-Flash-Next

LLMs Qwen Vision + text 6 builds Its own licence terms 121k dl/mo

Qwen3.8-Flash-Next is an open-weight language model from Qwen. Qwen3.8-Flash-Next-NVFP4 (NVFP4) weighs 133 GB; the smallest configuration that runs it is 2× H100 80 GB.

  • Qwen3.8-Flash-Next is an experimental image-text-to-text model developed by Qwen, featuring a 180.0B parameter architecture with a native context length of 262,144 tokens that is extensible up to 1,000,000 tokens.
  • The model utilizes hybrid attention mechanisms, including Gated DeltaNet and Qwen Sparse Attention, alongside n-gram embeddings to optimize long-context latency and parameter scaling efficiency.
  • It is released under an "other" license and supports deployment via frameworks such as Hugging Face Transformers, vLLM, and SGLang.

Summary of the Qwen/Qwen3.8-Flash-Next model card, 2026-10-01. The estimate below is for another build of the family.

What it is

Released byQwen
Released2026-08-24
Parameters180.0B
VRAM133 GB for the weights

What it runs on

Memory and cards for Qwen3.8-Flash-Next-NVFP4 (NVFP4)

133 GBweights, file size
25 MBcache per 1K tokens
231 MBfixed state per request
2.8 GBruntime overhead, at least
262,144 tokenscontext max
CardRequests at onceContext maxMemory
8K each32K each
RTX 3060 12 GB … H200 141 GB
11 smaller cards
———
B200 180 GB7029all 256K176 GB
2× H100 80 GB
tensor parallel · FP4 without its speed-up here
83128K78.1 GB a card
2× A100 80 GB
tensor parallel · FP4 without its speed-up here
4217all 256K78.2 GB a card
4× L40S 48 GB
tensor parallel · FP4 without its speed-up here
5017all 256K44.0 GB a card
2× RTX PRO 6000 Blackwell 96 GB
tensor parallel
8033all 256K93.8 GB a card
2× H200 141 GB
tensor parallel · FP4 without its speed-up here
285118all 256K138 GB a card
Memory needed at each load
Requests at once8K tokens each32K tokens each
1136 GB136 GB
5138 GB141 GB
8139 GB144 GB
16142 GB152 GB
32149 GB169 GB
64163 GB202 GB

One card, with vLLM's small-card settings.

Builds

Sizes, precisions & builds

BuildParamsPrecisionWeightsSmallest setup
Qwen3.8-Flash-Next ↗ 180.0BBF16 360 GB4× H200 141 GB
Qwen3.8-Flash-Next-FP8 ↗ 180.0BFP8 186 GB2× H200 141 GB
Qwen3.8-Flash-Next-GGUF ↗
packaged by unsloth
12 builds: Q4_K_M 4.7 GB … BF16 367 GB
—GGUF 4.7 GBRTX 3060 12 GB
Qwen3.8-Flash-Next-FP8 ↗
packaged by unsloth
180.0BFP8 186 GB2× H200 141 GB
Qwen3.8-Flash-Next ↗
packaged by unsloth
180.0BBF16 360 GB4× H200 141 GB
Qwen3.8-Flash-Next-NVFP4 (above) ↗
packaged by nvidia
119.6BNVFP4 133 GB2× H100 80 GB

From the model card

What Qwen says about Qwen3.8-Flash-Next

Read the model card

[!Note] This repository contains model weights and configuration files for the post-trained model in the Hugging Face Transformers format.

These artifacts are compatible with Hugging Face Transformers, vLLM, SGLang, TokenSpeed, etc.

[!Tip] For users seeking managed, scalable inference without infrastructure maintenance, the official Qwen API service is provided by Qwen Cloud.

In particular, Qwen3.8-Flash is the official version based on Qwen3.8-Flash-Next with more production features, e.g., 1M context length by default, official built-in tools. For more information, please refer to the Qwen3.8-Flash Overview.

As the frontier of foundation models pushes toward ever-larger parameter counts and ever-longer context windows, the question is no longer just how much we can scale, but how efficiently we can do so. Sustainable progress toward artificial general intelligence (AGI) that benefits everyone demands architectural innovation. Today, we are sharing a concrete step in that direction: Qwen3.8-Flash-Next.

This experimental preview of the architecture that will underpin Qwen4 is built around a fundamental rethinking of how the core components of modern large language models (LLMs) interact at scale.

Highlights

The first open-weight release under this architecture is Qwen3.8-Flash-Next, which introduces:

  • Hybrid Attention with QSA: The Gated DeltaNet and Gated Attention pairing has been reworked into Gated DeltaNet and Qwen Sparse Attention (QSA). Rather than selecting individual tokens for processing, QSA operates at the micro-block level. This cuts long-context latency significantly, a critical gain as agentic workloads increasingly dominate real-world usage.
  • Gated Residual: Residual streams with normalization are what make deep LLM training manageable. Gated Residual modulates information flowing through widened residual streams via an element-wise, data-dependent read gate and a per-branch scalar write gate. This brings finer-grained expressiveness across layers while preserving training stability and keeping inference overhead low.
  • N-gram Embedding: Embeddings provide a unique axis for parameter scaling that requires less computation and is more amenable to offloading than Mixture-of-Experts (MoE). By indexing with short n-grams, this approach makes parameter scaling highly efficient for memory-constrained accelerators without sacrificing quality.
  • Tailored Training Recipe: The Muon and AdamW optimizers are applied to specific weight categories to maximize efficiency. Guided by refitted scaling laws, we eliminate traditional batch-size warmups and start directly at the target batch size, substantially reducing total optimizer steps while safely supporting larger learning rates for robust convergence.

For more details, please refer to our blog post Qwen3.8-Flash-Next and the technical report.

We are excited to embark on this next chapter with you and welcome your feedback as we build what comes next.

Model Overview

  • Type: Causal Language Model with Vision Encoder
  • Training Stage: Pre-training & Post-training
  • Language Model
    • Number of Parameters: 125B with 6B activated, plus 51B n-gram embedding and 4B MTP
    • Hidden Dimension: 2560
    • Token Embedding: 248320 (Padded)
    • N-gram Embedding: 20,000,000 (bigrams/trigrams at layer 2)
    • Number of Layers: 48
    • Hidden Layout: 12 × (3 × (Gated DeltaNet → MoE) → 1 × (Qwen Sparse Attention → MoE))
    • Gated DeltaNet:
      • Number of Linear Attention Heads: 48 for V and 16 for QK
      • Head Dimension: 128
    • Qwen Sparse Attention:
      • Number of Attention Heads: 24 for Q and 2 for KV
      • Head Dimension: 256
      • Rotary Position Embedding Dimension: 64
      • Indexer Structure: MQA with 4 Query Heads and 1 Shared Key Head
      • Indexer Head Dimension: 128
      • Budget: 512 blocks or 2048 tokens
    • Mixture Of Experts
      • Number of Experts: 512
      • Number of Activated Experts: 10 Routed + 1 Shared
      • Expert Intermediate Dimension: 640
    • Gated Residual:
      • Number of Branches: 4
      • Bottleneck Rank: 320
    • LM Output: 248320 (Padded)
    • MTP: 1 layer, trained with multi-steps
  • Context Length: 262,144 natively and extensible up to 1,000,000 tokens.

Benchmark Results

.vl-table th{font-size:15px!important;line-height:1.2} .vl-table td:not(.benchmark-cell):not([colspan]){font-size:15px;line-height:1.2;vertical-align:middle} .vl-table .benchmark-cell{padding:12px 10px 12px 18px!important;vertical-align:middle} .vl-table .benchmark-capability{font-size:15px;font-weight:600;line-height:1.22;color:#171717} .vl-table .benchmark-name{margin-top:4px;font-size:11px;font-weight:400;line-height:1.2;color:#6B6B6B} .vl-table .metric-stack{display:flex;flex-direction:column;gap:7px;padding:3px 0} .vl-table .metric-label{font-size:10px;font-weight:400;line-height:1.1;color:#777} .vl-table .metric-value{margin-top:2px;font-size:15px;line-height:1.15;color:#171717} .vl-table .metric-pair{white-space:nowrap} .vl-table .metric-sep{color:#9A9A9A;padding:0 3px}

@media (prefers-color-scheme: dark){ .vl-table th,.vl-table td[colspan]{color:#8DA2FF!important;border-bottom-color:#8DA2FF!important} .vl-table td[colspan]{background:rgba(10,46,254,0.22)!important} .vl-table .benchmark-capability,.vl-table .metric-value{color:#E8E8E8!important} .vl-table .benchmark-name,.vl-table .metric-label{color:#A3A3A3!important} }

Language

Vision Language

Quickstart

For streamlined integration, we recommend using Qwen3.8-Flash-Next via APIs.

Serving Qwen3.8-Flash-Next

[!Important] Inference efficiency and throughput vary significantly across frameworks. We recommend using the latest framework versions to e

Quoted from the model card on Hugging Face. The full card is behind the Hugging Face link above.

© 2026 AxForge · EU-hosted AI infrastructure Pricing Docs Trust Privacy Terms