Qwen3.8-Flash-Next vs Qwen3.8-27B: Rent the Throughput or Own the Weights

Qwen3.8-Flash-Next and Qwen3.8-27B are two answers to the same question, published six days apart by the same lab, and the question is what a team should actually run when it wants a model from this generation it can put in front of production traffic. Qwen3.8-27B landed on August 13, 2026: a dense 27-billion-parameter model under Apache 2.0 whose 55.6 GB of BF16 weights fit on a single 24 GB card once quantised. Qwen3.8-Flash-Next arrived on Hugging Face on August 24 and on ModelScope on August 26: roughly 180B parameters stored, 6B activated per token, under the more restrictive Qwe​n Community License 1.0. One is a file. The other is a throughput profile. Choosing between them is mostly a question about which of those two things your workload actually needs.

They are closer relatives than the names suggest. Both carry a native 262,144-token context extensible to 1,000,000, both take text, image and video in and return text, and both run the same hybrid attention idea that A​libaba has been shipping since the Qwen3.5 generation — a majority of linear-attention layers doing the long-context work cheaply, a minority of full-attention layers handling the precise retrieval that linear attention is bad at. Where they stop being the same is everything downstream of that: licence, size, price per token, and what you have to do to get one running.

What each one is, in one paragraph each

Qwen3.8-27B is a dense causal language model with a vision encoder: 64 layers, hidden dimension 5120, an intermediate size of 17,408 and a 248,320-token vocabulary, with the attention stack split 48 Gated DeltaNet linear layers against 16 Gated Attention layers. A​libaba trained it with multi-token prediction. Thinking mode is on by default with `reasoning_effort` levels of xhigh, medium and low, and the model card's own vision rows cover document parsing (OmniDocBench 1.5 at 91.1), GUI work (OSWorld-Verified 84.3, AndroidWorld 81.9) and general visual reasoning (RealWorldQA 85.9, MathVision 90.0). It is, in the plain sense, a downloadable model: one repository, eighteen safetensors shards, a licence file, and a size that a serious workstation can hold.

Qwen3.8-Flash-Next is a mixture of experts on the architecture A​libaba says will underpin Qwen4 — 48 layers, 512 experts with 10 routed and one shared, 125B parameters in the expert body activating 6B per token, plus a separate 51B n-gram embedding table and around 4B of multi-token-prediction layers. Its attention stack is the same three-to-one idea at a different scale: 36 Gated DeltaNet layers against 12 running Qwen Sparse Attention. The card is explicit that this is an experimental preview of the architecture rather than a Qwen4 model, and that the served production variant is Qwen3.8-Flash through Qwen Cloud. It is not a file you casually own — it is a serving problem you solve once and then run cheaply.

Where the two diverge beyond the parameter count

The licence is the first divergence and the one that outlives every benchmark argument on this page. Qwen3.8-27B is Apache 2.0, full stop: commercial use, modification, redistribution, derivative builds, no revenue threshold and no separate agreement to negotiate. Qwen3.8-Flash-Next is Qwen Community License 1.0, which permits commercial use including selling derivative works but requires a separate commercial agreement with A​libaba if you run a model-as-a-service or AI-work-assistant business past a defined revenue and monthly-active-user threshold. If you are building a product rather than an internal tool, that clause is not a footnote; it is a line item. It is worth reading the licence before you read the benchmark table, because it can disqualify a model that wins on every score.

The second divergence is what "local" means. For the 27B, local means one machine: quantise to four bits and the model fits in a 24 GB card, with the format ladder — GGUF quantisation levels, MLX for Apple Silicon, the actual VRAM arithmetic — covered in detail on a sibling page rather than repeated here. For Flash-Next, local means provisioning for a 180B-parameter checkpoint. vLLM serves it from day one with an offload path that keeps the 51B-parameter n-gram table in host memory instead of permanent VRAM, SGLang and TensorRT-LLM are in N​VIDIA's Day 0 list, and Ollama's library carries an MLX build for Apple Silicon — but "runs" and "runs on the machine you have" are different sentences, and only the 27B gets to claim the second one.

What the public numbers say, and what they do not

Both models carry Artificial Analysis figures, from the same index, which makes this the rare intra-family comparison where the independent numbers can at least be read side by side. Qwen3.8-27B scores 33.7 on the Intelligence Index — 47th overall, 66th percentile — and 68.1 on the AA Coding Index, 35th overall. The open-weight Flash-Next preview scores 40 on the Intelligence Index, fifth among the 113 models in its comparison class. Those entries were evaluated on different dates, so read the gap as directional rather than as a controlled result.

The detail behind the two scores is more interesting than the scores. On the individual evaluations, the 27B's own card reports 90.3 on LiveCodeBench v6, 89.2 on GPQA Diamond and 79.0 on QwenSWEBench, while the Flash-Next preview's card reports 91.9, 91.7 and — on the same family's benchmark — 81.0 on SWE-bench Multilingual and 62.5 on SWE-bench Pro. All of those are the vendor's own numbers, produced by the vendor, and none of them has been reproduced by a third party on a matched harness. The independent picture is narrower and points the other way on some rows: the preview is strong on knowledge work and terminal tasks and weak on long-horizon repository generation, while the 27B's independent coding index of 68.1 sits below its own vendor-reported SWE figures would suggest.

One practical difference the index does capture: the preview is verbose. Artificial Analysis measures it at 53 output tokens per second with a 2.80-second time to first token and calls it "very verbose", burning 108k output tokens per task of which 72k are reasoning. The 27B, measured through our own playground across the last seven days, returns just over 200 output tokens per second at a 4.97-second median first token. Different harnesses, so treat the rates as indicative — but they describe the same shape the architecture implies. One spends tokens to reach an answer; the other spends fewer, and the dense design makes each of them cheaper to produce.

Price, on both of the units that matter

Per token, the two are close enough that the decision is not made here. Qwen3.8-27B is routed at $0.33 per million input tokens and $2.40 per million output; the served Qwen3.8-Flash is routed at $0.15 and $0.47, both at the provider's list price passed through with no markup. So the production Flash variant is roughly 2.2x cheaper on input and 5.1x cheaper on output.

Per byte on disk, they are not close at all, and this is the number readers underestimating local deployment usually miss. The 27B is 55.6 GB of BF16 weights across eighteen shards, compressible to something that runs on a single consumer card. The preview is a 180B-parameter checkpoint in the same precision — several times the storage, several times the memory bandwidth, and a serving configuration that assumes host-memory offload rather than a single device. If your constraint is a machine you already own, the 27B is not the cheaper option; it is the only option.

Which one to run

Choose Qwen3.8-27B if you need to own the model rather than rent it: on-premise or air-gapped deployment, an Apache 2.0 licence you can build a product on without a revenue conversation, per-request costs that do not scale with someone else's rate card, and a single-GPU serving story you can operate yourself. It is also the right side of this pair when you need to fine-tune, merge, or quantise — the repository shows hundreds of community adapters, finetunes and quantisations already derived from it, which is what an Apache 2.0 weights release buys you over time.

Choose Qwen3.8-Flash-Next if your constraint is throughput and cost per token rather than control: high-volume agentic sweeps, wide classification and extraction work, screenshot and document understanding at scale, and anything where a 6B-active model at a third of the input price changes what is economically possible. It is also the right choice if you specifically want to evaluate the Qwen4 architecture on your own data before Qwen4 exists — that is precisely what the preview is for, and it is a reason to test rather than a reason to commit.

The rule: the 27B is for readers whose bottleneck is where the model runs, and Flash-Next is for readers whose bottleneck is what the model costs to run. Very few teams have both bottlenecks, and the one they actually have usually decides this in a single meeting.

Getting either one running today

Qwen3.8-27B is the easier of the two to start with, in two directions at once. Download the weights and serve them yourself under Apache 2.0, or call it without touching an accelerator: it is routed as `qwen/qwen3.8-27b` on our catalogue at $0.33 and $2.40 per million tokens, and the 27B is served on our own infrastructure rather than proxied from a vendor endpoint. That second path is what makes it a genuine default for high-volume multimodal work — as one of more than 200 models reachable through a single OpenAI-compatible endpoint, on one key, with no second contract to sign.

Qwen3.8-Flash-Next is not a route we offer. The open-weight preview has to be downloaded and served by you, and the availability path for it runs through Hugging Face and ModelScope rather than through an API. What we do route is its production sibling: Qwen3.8-Flash, `qwen/qwen3.8-flash`, at $0.15 and $0.47 per million tokens with text, image and video input on a 1M-token context, priced at the vendor's published list so a rate change on A​libaba's side reaches your endpoint the same day. If you want the preview's architecture without the serving project, that is the closest thing to it that is callable today.

For a team that wants both, the arrangement is a traffic split rather than a decision. Both live behind the same key and the same SDK, so a percentage of requests can go to the 27B while the rest goes to the Flash endpoint, with automatic failover absorbing the moments when either side misbehaves. That is a cheaper way to answer this comparison than any benchmark table, because it measures your traffic rather than someone else's.

What is not settled is what happens when the family completes. Qwen3.8-27B is a finished, licensable, downloadable model that is unlikely to change underneath you. The Flash-Next preview is a canary for an architecture whose production models have not shipped, and the served Flash variant it accompanies is explicitly positioned as the official version of that architecture. If the Qwen4 family follows the pattern Qwen3-Next set in late 2025, the preview's descendants will arrive within months and this page will be a decision about a generation rather than about a preview.

The one fact that decides this pairing most often is the licence, not the benchmark: Apache 2.0 lets you build a business on the 27B without asking anyone, and Qwen Community License 1.0 does not give you that for the preview. Everything else on this page — the context window, the hybrid attention, the vision support — the two of them share.