Meet Qwen3.8-Flash: an open-weight multimodal MoE that previews the Qwen4 architecture — $0.15/$0.47 per 1M tokens on QwenCloud

On August 26, 2026, the Qw​en team open-sourced the weights behind Qwen3.8-Flash — released on Hugging Face and ModelScope under the name Qwen3.8-Flash-Next — and launched the production model that carries the Qwen3.8-Flash name on the QwenCloud API, confirming its official pricing the next day. The headline figure — officially confirmed in Alibaba's own announcement on August 28 — is a 125-billion-parameter multimodal mixture-of-experts that activates only about 6 billion parameters per token, a sparsity of roughly 95%, built on an architecture Alibaba explicitly describes as an early preview of the Qwen4 generation. The production API is live on QwenCloud at $0.15 per million input tokens, $0.47 per million output tokens, and $0.016 per million on cache hits — the cheapest way to run something structurally descended from Alibaba's next flagship, and the first time the lab has shipped an architecture preview as public open weights before the full model family exists.

One number carries more weight than the rest of the spec sheet: 6B. Qwen3.8-Flash does not get its capability from brute size — it gets it from where it puts the compute. A 125B MoE body, a 51B N-gram embedding table, and a small multi-token-prediction module store close to 180B parameters on disk, yet each token routes through just 6B of them. That is the bet this entire release stands on, and it is the reason the training bill came down so far.

What actually shipped

Qwen3.8-Flash, without the suffix, is the productionized model now live on the QwenCloud API and inside Alibaba's Qw​en Office product; it ships with a 1M-token default context and built-in tools, at $0.15/$0.47 per million tokens with cache hits at $0.016. On August 28 the availability list widened: per Alibaba's announcement, Qwen3.8-Flash is now also reachable through OpenCode Go, the open-source terminal coding agent's flat-rate subscription — OpenCode's own model list carries it as qwen3.8-flash at the same $0.15/$0.47 per-million rates.

The official Qw​en Studio announcement frames the open-weights release as an invitation to the ecosystem: ship the structural changes early so the community and the inference stacks can adapt before the full Qwen4 lineup is built. The first sign that worked is SGLang — the LMSYS-backed inference engine — publishing day-0 support for Qwen3.8-Flash-Next on the same day, with the model also configured for Transformers, vLLM, and TokenSpeed.

The architecture is the story

This is not a Qw​en 3.8-generation model scaled down. Qwen3.8-Flash introduces four changes the team says the Qwen4 family will inherit, and each one targets a different bottleneck.

• Attention — Gated DeltaNet plus Qw​en Sparse Attention. Gated DeltaNet (GDN) compresses history into fixed-size states in three of every four layers, so the model does not re-read everything at every step; QSA then treats long context as a search problem — a lightweight indexer aggregates the sequence into micro-blocks, scores block-level importance, and routes attention to the most relevant regions. On Alibaba's measurements the QSA attention kernel reaches up to 7.6× faster prefill and 4.9× faster decode at 1M-token context (vendor-reported).

• Residual — Gated Residual. The single residual stream becomes four parallel branches with element-wise gating, letting the network decide per token how much to read and write on each branch; one branch settles into a long-distance channel connecting early attention layers to deep ones. Residual states are stored in FP8 to cut memory bandwidth.

• Embedding — N-gram embeddings. A 51B-parameter lookup table keyed on the current token plus several preceding ones. It adds capacity without adding per-token compute, and because the table can live in host memory and be asynchronously prefetched, it does not permanently occupy GPU memory.

• Optimizer — Muon. Large 2D-linear parameters (attention, GDN, MoE experts) train with Muon, while embeddings, the router, and the Gated Residual low-rank parts keep AdamW; the team re-fit the scaling law for the new architecture around the mix.

For a developer, two of these matter immediately: the attention stack is why 1M-token context can be a default rather than a stretch goal, and the N-gram table is why a 125B model can still be served lean. The rest is preview material for Qwen4 — which is precisely how Alibaba is positioning it.

The benchmark sheet, honestly labeled

Every number in this section is Alibaba's own evaluation, one day old and unreproduced by any independent lab at the time of writing. Take them as directional claims, not settled scores. On Alibaba's suite, Qwen3.8-Flash-Next (6B active) records SWE-bench Pro 62.5, DeepSWE 1.1 58.7, CoWorkBench 73.9, AndroidWorld 84.5, and MathVision 95.7, with a JobBench score of 55.7 — and the base variant, Qwen3.8-Flash-Next-Base, is reported as the best open model on 8 of 14 benchmarks in a head-to-head sweep, including MMLU-Pro, SuperGPQA, BBH, and MMMU.

Alibaba's family-placement claims should be labeled as what they are — claims. The company says Qwen3.8-Flash beats Claude Opus 4.6 by 9.1 points on SWE-bench Pro and roughly 20 points on JobBench, and closes to within reach of Claude Opus 4.8. All vendor-reported, all unreproduced. What is independently checkable today is narrower: the weights are out, the inference stack already runs them, and SGLang shipped support the same day. The independent reproduction of the benchmark sheet is days away, not weeks.

What it costs

The pricing is the easiest part to verify, because it is a published price rather than a benchmark — and on August 27 Alibaba confirmed the production QwenCloud rate officially: $0.15 per million input tokens, $0.47 per million output tokens, and $0.016 per million on cache hits, with the domestic China rate at ¥0.8/¥2.7/¥0.1. The cache-hit number is the one that matters for agentic workloads: a long-context agent that re-reads a large history on every turn pays pennies on repeat reads, which is exactly the workload the Qwen4-preview attention stack targets. Chinese press coverage immediately compared the headline price to peers — roughly a third of what DeepSeek-V4-Flash charges, and a rounding error beside frontier closed models. On Alibaba's own accounting, the training run cost about one-ninth of Qwen3.7-Plus, and that structural leverage is what lets the API price sit where it sits.

Next to the rest of the Qw​en 3.8 family, the gap is stark: the flagship Qwen3.8-Max bills at $2.00 and $6.00 per million tokens, and it is already live on OrcaRouter at provider list price with zero markup. Now that the production Qwen3.8-Flash API is open, the same pass-through applies to the official $0.15/$0.47 rate and the $0.016 cache-hit rate — a routing layer is the difference between reading about a price cut and having it in a config. Both models behind one key, failover between them, no second contract.

What "preview of Qwen4" means

Read the announcement literally and the stakes are clear: this is not a new tier of Qw​en 3.8 — it is Qwen4's architecture shipped early, under the protective brand of a smaller, cheaper model. The reasons to do that are sound: frameworks, quantization, and deployment patterns need time to mature, and a 6B-active model is a cheap way for the community to stress-test GDN + QSA at scale before Alibaba builds the expensive thing on top of it. The flip side is that the production Qwen3.8-Flash is an API built on an architecture the wider ecosystem is still auditing. Early adopters are, by construction, the test set.

The fast path to trying it

Today you have four realistic options. Self-host the open weights through vLLM, SGLang, Transformers, or TokenSpeed — the FP8 build is the sensible first stop on anything short of a full node. Call the QwenCloud API, now live at the official $0.15/$0.47 rate with cache hits at $0.016. Use it inside OpenCode Go, the open-source terminal coding agent's flat-rate subscription, which added Qwen3.8-Flash this week (announced by Alibaba on August 28, confirmed on OpenCode's own model list). Or call the production Flash through a router the way you already call Qwen3.8-Max, with the official rate passed through at zero markup — no bespoke integration to maintain.

The open question is the honest one: can a model that activates 6 billion of its parameters hold up in production across a wide range of workloads, or will the benchmark sheet that looks one-day-old today still look that way in a month? That is not a reason to wait — it is a reason to put it behind failover rather than in front of your entire stack. The weights are out, the price is set, and the architecture is Alibaba's declared direction. The next few weeks decide whether 6B was enough.