Qwen 3.8 Flash: 1M Context at $0.15/M (2026 Guide)

Alibaba listed qwen/qwen3.8-flash on OpenRouter on 26 August 2026, two days after pushing the open weights to Hugging Face. It is the cheap tier of the Qwen 3.8 family, and it is the variant most people building an actual product will reach for — the 27B is for local rigs, Max is for when budget is not the constraint, and Flash is for everything in between.

It is also the most architecturally interesting model Alibaba has shipped this year, because it is not a shrunken Qwen 3.8. It is a preview of Qwen4.

What is Qwen 3.8 Flash?

Qwen 3.8 Flash is a sparse mixture-of-experts multimodal reasoning model. Two names matter and people conflate them constantly:

• Qwen3.8-Flash-Next — the open-weight checkpoint on Hugging Face, native 262,144-token context.
• Qwen3.8-Flash — the hosted API version built on those weights, with 1M context enabled by default and built-in tools. This is what you get on Qwen Cloud and OpenRouter.

Same model family, different packaging. The weights are real; the API adds production features on top.

The architecture is where it diverges from everything else Qwen has shipped. The model type in config.json is literally qwen4_exp, and the card describes it as "an experimental preview of the architecture that will underpin Qwen4." Four things are new:

• Qwen Sparse Attention (QSA) replaces the old gated-attention pairing, selecting micro-blocks rather than individual tokens. The indexer runs on a budget of 512 blocks / 2,048 tokens, which is what keeps long-context latency down.
• Gated DeltaNet linear-attention layers make up three of every four layers — the layout is 12 repeats of 3 × (Gated DeltaNet → MoE) → 1 × (QSA → MoE). Only 12 of 48 layers use full attention.
• N-gram embedding — a 20-million-entry bigram/trigram table at layer 2. This is the 51B chunk. It scales parameters on an axis that needs almost no compute and, critically, can be offloaded to slower memory.
• Gated Residual — 4 branches at bottleneck rank 320, adding per-layer expressiveness without inference overhead.

The practical upshot: 180B parameters on disk, but only 6B fire per token, and a third of the file is a lookup table you can push off the GPU.

How does it fit in the Qwen 3.8 family?

Qwen 3.8 has four public members, and the naming does them no favours. Here is the summary — for a full breakdown of every variant see our Qwen 3.8 model lineup guide.

Two things worth flagging. First, Flash is not the smallest model — it is the cheapest. At 125B total it is far larger than the 27B, but because only 6B activate it serves for roughly a third of the 27B's API price. Second, the licences differ across the family. The 27B is Apache 2.0. Flash is not.

What does Qwen 3.8 Flash cost, and how does it compare?

Pricing below is from the live OpenRouter model catalogue and the Qwen Cloud model page, both checked on 3 September 2026.

Qwen 3.8 Flash is not the cheapest option — GLM-5.3-Flash undercuts it by half on input and DeepSeek V4-Flash is cheaper still on output. But both of those are text-only. Against the models that actually accept images and video, Flash is 5× cheaper than Gemini 3.8 Flash on input and 8× cheaper on output, which is the comparison that matters if your workload involves screenshots, documents or video frames.

The cached-input rate is the sleeper feature. At $0.016 per 1M tokens that is an 89% discount on repeated context, per Artificial Analysis's measurement. If you are running an agent that replays a large system prompt or codebase on every turn, that line dominates your bill far more than the headline rate.

How good is Qwen 3.8 Flash?

Two sources, kept deliberately separate.

Vendor-reported (Alibaba's own model card)

Alibaba benchmarks Flash-Next against its own 27B, the previous-generation Qwen3.7-Plus, DeepSeek-V4-Flash-0731 and Claude Opus 4.6.

Treat these as vendor numbers. The agentic-coding scores were produced with the Claude Code and mini-SWE-agent harnesses at 256K context, and Alibaba notes it reports the better of the two harnesses for DeepSWE. The JobBench gap (55.7 vs 33.4 for the 27B) is the single most striking result, and it is an in-house-adjacent benchmark, so weight it accordingly.

Independent (Artificial Analysis)

Flash-Next scores 56, ranking #5 of 111 models measured, against a median of 29. Note that GLM-5.3-Flash edges it on raw intelligence while running at roughly half the output speed — the honest read is that these two are close on quality and differ on latency and modality, not that Qwen wins outright.

One caveat worth budgeting for: Artificial Analysis flags Flash-Next as "very verbose," generating 200M output tokens across their evaluation versus a 110M median. Since output tokens cost 3× input, a chatty reasoning model can quietly erase its price advantage. Dial reasoning_effort down to medium or low for tasks that do not need deep thinking.

Can you run Qwen 3.8 Flash locally?

Yes — this is the answer that surprises people, given "Flash" usually signals an API-only tier. The Qwen3.8-Flash-Next weights are public, and the community shipped quantisations within days. The Unsloth GGUF repo alone has over 430,000 downloads.

Those numbers look brutal, but the architecture is unusually forgiving. Only 6B parameters activate per token, and the 51B n-gram embedding is a lookup table that Alibaba explicitly designed to be offloaded — the card calls it "highly efficient for memory-constrained accelerators." Community repos already exploit this: there are SSD-offloaded n-gram builds, NVFP4 quants, MLX mixed 2-bit and 4-bit variants for Apple Silicon, and an official FP8 checkpoint from Qwen.

Supported serving stacks are SGLang, vLLM, TokenSpeed and Hugging Face Transformers, with llama.cpp and LM Studio builds available from the community. If you want a GPU-by-GPU walkthrough for the family, see how to run Qwen 3.8 locally — though be clear-eyed that the 27B is the variant most people should self-host. Flash-Next is a 180GB-class download that is usually cheaper to rent than to run.

How do you use Qwen 3.8 Flash?

The API is OpenAI-compatible everywhere it is served. Model strings differ by provider: qwen3.8-flash on Qwen Cloud, qwen/qwen3.8-flash on OpenRouter, and Qwen/Qwen3.8-Flash-Next when self-serving.

curl https://openrouter.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $OPENROUTER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen/qwen3.8-flash",
    "messages": [{"role": "user", "content": "Summarise this repo'\''s test strategy."}],
    "reasoning": {"effort": "medium"}
  }'

In Python, with streaming and the reasoning trace separated from the answer:

from openai import OpenAI

client = OpenAI(
    base_url="https://openrouter.ai/api/v1",
    api_key=OPENROUTER_API_KEY,
)

completion = client.chat.completions.create(
    model="qwen/qwen3.8-flash",
    messages=[{"role": "user", "content": "Write a Python function to merge two sorted linked lists."}],
    reasoning_effort="medium",   # xhigh (default), medium, low
    stream=True,
)

for chunk in completion:
    delta = chunk.choices[0].delta
    if getattr(delta, "reasoning", None):
        print(delta.reasoning, end="", flush=True)
    if delta.content:
        print(delta.content, end="", flush=True)

Alibaba's recommended sampling parameters are temperature=1.0, top_p=0.95, top_k=20 in thinking mode, and temperature=0.7, top_p=0.80, top_k=20, presence_penalty=1.5 for non-thinking. Thinking is on by default; disable it with chat_template_kwargs: {"enable_thinking": false}.

Qwen Cloud rate limits are 2M tokens per minute and 15,000 requests per minute. Image and video inputs use the standard image_url and video_url content blocks.

One documented gotcha from the model card: in multi-turn agent loops, lowering reasoning effort does not reliably reduce total latency. Shallower analysis means more failed attempts and retries, which can cost more wall-clock time and more tokens than just letting it think.

Which cheap-tier model should you actually pick?

A decision rule rather than a verdict:

• Your inputs include images, video or screenshots → Qwen 3.8 Flash. GLM-5.3-Flash and DeepSeek V4-Flash are text-only, so the cheaper price is irrelevant. Against Gemini 3.8 Flash you save roughly 5–8×.
• Pure text, cost is the only axis → GLM-5.3-Flash or DeepSeek V4-Flash. Both are MIT-licensed and cheaper. GLM even scores a point higher on the Artificial Analysis index.
• You replay a large fixed context every call → Qwen 3.8 Flash, for the $0.016 cached-input rate.
• You need to self-host on one GPU → not Flash. Use Qwen 3.8 27B, which is Apache 2.0 and fits in 17GB quantised.
• You are building a commercial model-serving or AI coding-assistant product → read the licence before you build. Flash's terms are narrower than the 27B's Apache 2.0.

The broader point: Qwen 3.8 Flash is the first cheap-tier model where the multimodal capability is not a downgrade. It beats Claude Opus 4.6 on SWE-bench Pro on Alibaba's own harness, at 1/40th of Opus pricing. Verify that on your own workload before you believe it — but it is close enough to be worth the afternoon.

If you are weighing this generation against the previous one, our Qwen 3.5 developer guide covers where the family started.

FAQ

What is Qwen 3.8 Flash?

Qwen 3.8 Flash is Alibaba's low-cost, high-speed multimodal reasoning model in the Qwen 3.8 family, released in late August 2026. It is a sparse mixture-of-experts model with 125B total parameters and 6B active per token, accepts text, image and video input, and supports a 1M-token context window through the hosted API.

How much does Qwen 3.8 Flash cost?

Qwen 3.8 Flash costs $0.15 per 1M input tokens and $0.47 per 1M output tokens. Cached input drops to $0.016 per 1M — an 89% discount — and explicit cache writes cost $0.20 per 1M. Pricing is identical on Qwen Cloud and OpenRouter, since Alibaba is currently the only serving provider.

Is Qwen 3.8 Flash open source?

The weights are public but the licence is not OSI-approved open source. Qwen3.8-Flash-Next ships under the Qwen Community License 1.0, which permits commercial use and fine-tuning, but requires attribution if your product exceeds 100M monthly users or $20M monthly revenue, and requires a separate licence if you run a model-as-a-service or AI coding-assistant business.

Qwen 3.8 Flash vs Qwen 3.8 27B — which should I use?

Use the 27B if you are self-hosting: it is dense, Apache 2.0, and fits on a single 16–24GB GPU when quantised. Use Flash if you are calling an API: it is roughly a third of the 27B's hosted price and beats it on almost every published benchmark, including 58.7 vs 42.2 on DeepSWE 1.1 and 55.7 vs 33.4 on JobBench.

Can I run Qwen 3.8 Flash locally?

Yes. Qwen3.8-Flash-Next weights are on Hugging Face and run under vLLM, SGLang, TokenSpeed or Transformers, with community GGUF, NVFP4, FP8 and MLX quantisations available. Practical sizes range from about 73GB at 1-bit to 111GB at 4-bit, so you need 96–192GB of unified memory or a multi-GPU rig.

Is Qwen 3.8 Flash better than GLM-5.3-Flash?

Not on raw intelligence — Artificial Analysis scores GLM-5.3-Flash at 57 versus 56 for Qwen3.8-Flash-Next, and GLM is half the price on input. Qwen wins on two axes that often decide it: it generates output roughly twice as fast (86.4 vs 44.6 tokens/sec) and it handles image and video input, which GLM-5.3-Flash does not.

What context window does Qwen 3.8 Flash support?

The hosted Qwen 3.8 Flash API supports 1,000,000 tokens of context, with a maximum input of 991K and a maximum output of 131,072 tokens. The open-weight Qwen3.8-Flash-Next checkpoint is natively trained at 262,144 tokens and is extensible to 1M, so self-hosted deployments need explicit context extension to match the API.