Qwen3.8-Flash-Next API: 125B MoE with GDN + QSA Hybrid Attention

On August 26, 2026, Alibaba released Qwen3.8-Flash-Next — an open-weight, 125B-total-parameter Mixture-of-Experts model that activates only 6B parameters per token and is the first Qwen model to combine Gated DeltaNet (GDN) with Qwen Sparse Attention (QSA) in a single hybrid stack. The Hugging Face config.json declares the architecture class as Qwen4ExpForConditionalGeneration, and the GitHub README explicitly describes it as an "early preview of the architecture used in Qwen4." It shipped the same day as Qwen3.8-Flash, the hosted-only production variant that OpenRouter lists at $0.15/M input + $0.47/M output. This review covers the verified architecture, the training-cost claim ("about 1/9" of Qwen3.7-Plus), the qwen-community-1.0 license, where to access each variant, and how Flash-Next fits against Qwen3.8-Max (2.4T flagship) and Qwen3.7-Plus for long-context workloads.

The Qwen3.8 lineup (2026-08-26)

The naming convention can mislead: "Flash-Next" is the experimental open-weight sibling of "Flash," not a successor. The "Next" suffix signals that this is a research line that previews the architecture Qwen4 will use. The "Flash" name (without -Next) is the hosted, production-ready drop-in for the existing Qwen API surface.

Architecture: GDN + QSA hybrid attention

The headline innovation is the attention stack. Qwen3-Next-80B-A3B-Instruct (the previous experimental line) used a hybrid of Gated Attention (a windowed full-attention with a learned gate on the value) and standard full attention. Qwen3.8-Flash-Next swaps Gated Attention for Gated DeltaNet (GDN), a linear-attention block that processes tokens in linear time and memory at the cost of some precision, paired with Qwen Sparse Attention (QSA), a windowed/sparse full-attention block that runs only on selected token positions. Verified from config.json on Hugging Face:

• 48 total layers organized into 12 macro-blocks of 4 layers each
• Each macro-block: 3× (GDN → MoE) followed by 1× (QSA → MoE)
• MoE: 512 experts per layer (10 routed + 1 shared active per token)
• Other components: Gated Residual connections, N-gram Embedding (51B extra params for next-token-aware embeddings), Multi-Token Prediction (4B extra), Muon + AdamW optimizer

Why this matters for API cost: linear attention (GDN) is O(n) in sequence length, dense attention is O(n²). By making 3 of every 4 layers linear, the dominant cost in long contexts collapses. QSA, the sparse full-attention block, only runs on every fourth layer — Alibaba positions it as a precision-restore step that catches the cases where pure linear attention would lose recall. The result, per Alibaba's claim in the README, is training cost "about 1/9" of Qwen3.7-Plus at comparable capability.

Verified facts (captured 2026-08-28)

Why a Qwen4-preview matters for API users

Open-weight preview releases are unusual in this category. Most labs ship a paper, an API, and weights months later. Alibaba shipped config.json with model_type: qwen4_exp on day one — which is itself a strong signal that the architecture will land in Qwen4 production. For API users, that means three things matter:

1. Distillation targets are stable. Teams that need to fine-tune a smaller Qwen3.5 / Qwen3.7 model on Flash-Next outputs can do so today and keep that pipeline when Qwen4 ships. Fine-tuning on a 125B MoE is not cheap, but Qwen3.5-7B-Instruct or Qwen3.5-14B-Instruct distilled from Flash-Next outputs is.
2. Linear attention economics arrive first. If the GDN+QSA stack proves durable in Qwen4 production, the long-context API economics improve. Flash-Next is the canary — if its long-context recall holds up in benchmarks, expect the same attention layout to land in Qwen4 closed weights at flagship tier.
3. Hosted price card is the production route today. If you do not need open weights, Flash (non-Next) at $0.15/M input + $0.47/M output is the entry point — same architecture, multimodal (text + image + video → text), 1M context by default, no self-hosting.

OpenAI-compatible integration (DashScope)

The hosted surface is the OpenAI-compatible DashScope endpoint. The model ID for the Flash production variant on DashScope and OpenRouter is qwen3.8-flash; Flash-Next is not yet on either surface as of 2026-08-28.

from openai import OpenAI

client = OpenAI(
    base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
    api_key="YOUR_DASHSCOPE_API_KEY",
)

response = client.chat.completions.create(
    model="qwen3.8-flash",
    messages=[
        {"role": "system", "content": "You are a precise financial analyst."},
        {"role": "user", "content": "Summarize the Q2 2026 risk factors from this 10-K excerpt."},
    ],
    max_tokens=800,
    temperature=0.2,
)
print(response.choices[0].message.content)

For multimodal calls (image or video URL → text), pass content as an array of parts. For long-context calls, set max_tokens generously — the Flash production variant defaults to 1M context, but output tokens still bill at the per-1M output rate.

Self-hosting Flash-Next (open weights)

The HF repo is Qwen/Qwen3.8-Flash-Next. The 125B MoE with 51B N-gram embeddings and 4B MTP totals about 180B parameters; in fp16 that is roughly 360 GB on disk, in bf16 with the N-gram embeddings kept in fp8 the practical load is 220-260 GB. Production hosting means 4×H100 or 4×A100-80GB nodes; research hosting is feasible on a single 8×H100 box. Use vLLM 0.6+ or SGLang for serving — both support the Qwen4ExpForConditionalGeneration architecture class.

# vLLM serve example (verify against the HF repo's README for current flags)
python -m vllm.entrypoints.openai.api_server \
  --model Qwen/Qwen3.8-Flash-Next \
  --tensor-parallel-size 4 \
  --max-model-len 262144 \
  --enable-prefix-caching \
  --port 8000

The qwen-community-1.0 license permits commercial use with attribution; check the LICENSE file in the repo for the full use-case boundary. Some Qwen3.5 Apache-2.0 allowances (unrestricted fine-tuning, redistribution with changes) are restricted under qwen-community-1.0, so a legal review is worth doing before deploying.

Pricing comparison (verified 2026-08-28)

Hosted Flash is roughly 3.6× cheaper on input than Qwen3.5-Plus and 7.3× cheaper on input than Qwen3.8-Max. The 1M context default is the strongest single argument for switching from Plus to Flash on long-document workloads.

When to pick Flash-Next vs Flash vs Plus

Pick Qwen3.8-Flash (hosted) when you want the lowest per-token price at a 1M context window and do not need to inspect or fine-tune weights. OpenRouter qwen/qwen3.8-flash works with the OpenAI Python SDK; DashScope supports multimodal natively.

Pick Qwen3.8-Flash-Next (open) when you need weights — distillation pipelines, fine-tuning on your own data, on-prem deployment for data-residency reasons, or research on the GDN+QSA architecture that Qwen4 will inherit. Budget 4×H100 for production-grade inference and review the qwen-community-1.0 license terms.

Pick Qwen3.8-Max when single-turn quality matters more than cost. The 2.4T flagship still leads on hard reasoning and code-generation benchmarks; Flash targets a different niche.

Pick Qwen3.5-Plus when you want an Apache-2.0 self-hostable model at slightly higher cost than Flash but without the qwen-community-1.0 license friction. Apache 2.0 is the most permissive Qwen license currently shipping.

Limitations and risks

1. No public Flash-Next pricing as of 2026-08-28. Self-hosting is the only route with verifiable economics today. Treat any third-party price claim with caution.
2. License is qwen-community-1.0, not Apache 2.0. The Apache 2.0 license that most Qwen3.5 weights ship under does not apply here. Review the LICENSE file in the HF repo before commercial deployment.
3. OpenRouter does not list Flash-Next. Only Flash (hosted) is on OpenRouter. If your stack is OpenRouter-only, you will route through qwen/qwen3.8-flash, not the open-weight variant.
4. Self-hosting cost is non-trivial. 180B parameters in fp16 = ~360 GB VRAM minimum; production serving wants 4×H100 or 4×A100-80GB.
5. Long-context extension uses YaRN. Native 256K is fully validated by Alibaba; the 1M extension is YaRN-style and not benchmarked as deeply in the public docs.
6. Multimodal is on the hosted Flash, not the open Flash-Next. If you need image or video → text, you route through DashScope or OpenRouter, not the self-hosted weights.

Verdict

Qwen3.8-Flash-Next is a credible, open-weight preview of the architecture Alibaba will ship in Qwen4. The GDN+QSA hybrid is a meaningful step past Qwen3-Next's Gated Attention — linear blocks dominate the long context, sparse full-attention blocks rescue precision every fourth layer, and the verified "1/9 training cost vs Qwen3.7-Plus" claim (per the GitHub README) is the kind of efficiency math that, if it holds in production, will reshape long-context API economics in the second half of 2026.

For API users, the decision tree is short. If you want cheap long-context today, Qwen3.8-Flash (hosted) at $0.15/$0.47 on DashScope or OpenRouter is the entry point — multimodal, 1M context, OpenAI-compatible. If you need weights for distillation, fine-tuning, or on-prem, Qwen3.8-Flash-Next on Hugging Face is the only open option, with a 4×H100 self-hosting budget and qwen-community-1.0 license terms.

The flagship Qwen3.8-Max still wins on hard-reasoning benchmarks at 7× the input price; the Qwen3.5-Plus Apache-2.0 line is the right pick when license friction matters more than cost.

If you are routing Qwen3.8-Flash alongside OpenAI, Anthropic, or Groq behind a single OpenAI-compatible key with cross-region failover, FreeModel is the simplest handoff: one dashboard, one billing relationship, and routing controls without glue code.

Sources

• Qwen, Qwen3.8-Flash-Next model card (HF)
• Qwen, Qwen3.8-Flash-Next config.json (HF)
• Qwen, Qwen3.8-Flash-Next GitHub README (1/9 cost claim, News section)
• Alibaba Cloud, Qwen3.8-Flash product page (QwenCloud pricing)
• OpenRouter, qwen/qwen3.8-flash model page
• OpenRouter, /api/v1/models listing (Flash-Next absence verified)
• Qwen, Qwen3.8-Flash-Next official blog