← All posts

Explainer

Qwen3.8-Max open weights: smaller model, bigger download

Qwen3.8-Max is the first Max-class Qwen ever open-sourced, and the download is 4.89 TB — three times Kimi K3, for a model 400 billion parameters smaller. Alibaba published the checkpoint to Hugging Face as Qwen3.8-2.4T-A95B on August 12, 2026: 2.4 trillion total parameters, 95 billion activated per token, every weight in BF16. The vLLM recipe puts the hardware floor at 24 GPUs for that native precision, 16 for the official FP8, 8 for a community NVFP4 quant. Against a list API price of $2 per million input and $6 per million output, self-hosting economics do not invert at any volume most teams will ever see. What the release buys is optionality — audit, no vendor lock, private deployment, the right to modify — plus one thing Moonshot never shipped: a sibling most readers can actually run, the Apache-2.0, 55.6 GB Qwen3.8-27B.

What actually shipped, and when

Get the timeline right first, because the August 3 coverage announcing an "open-source Qwen3.8-Max" described a promise, not a release. On August 3 the model went live API-first, with weights pledged for "next week." The Hugging Face repo was created August 8, the 213 safetensors shards were uploaded August 9, the model card landed August 11, and the LICENSE file — the last piece — arrived August 12 at 10:24 UTC, when the repo went public. The 27B sibling, announced the same day as Max, slipped further: its weights uploaded August 13 and its license appeared August 14.

One distinction matters more than any spec row: the checkpoint is not the product. The model card says it plainly — "Qwen3.8-Max," the thing you call on Qwen Cloud, is the official version of this checkpoint plus vision input, non-thinking support, 1M context by default and built-in tools. The open weights are text-only, natively 262,144 tokens, and always reason: the chat template raises an exception if you pass enable_thinking: false. K3 shipped its vision tower in the weights; Qwen kept vision on the API side.

Why a smaller model is a three-times-bigger download

Kimi K3 is 2.8T parameters in 1.56 TB because Moonshot quantization-aware-trained the MoE experts to MXFP4 — the compression dividend was spent before release, which is why K3's community quants hurt so much. Qwen made the opposite call: 2.4 trillion parameters at two bytes each, 4.89 TB, no tricks. The arithmetic checks out exactly — 2,446,182,725,504 parameters, all BF16, is 4,892,365,449,008 bytes of tensors.

That choice cuts both ways. The download is brutal, but the quantization headroom is intact. Qwen's own FP8 repo halves it to 2.50 TB. The community NVFP4 build packs the experts to roughly 1.45 TB — landing near K3's native size — and it is that artifact, not a Qwen one, that the vLLM recipe serves on its 8-GPU low-latency path. Where K3's 1-bit GGUF still weighed 594 GB, Qwen's smallest usable GGUF is 397 GB. Full precision in, more room to compress out.

Qwen3.8-Max vs Kimi K3, head to head

Our K3 self-hosting post worked these numbers from the K3 repo and vLLM's day-0 guidance; the Qwen column comes from the same kind of primary sources.

The summary: K3 is the easier native self-host and the only one with open vision; Qwen is the cheaper API by 2.5x on output, ships its own draft model, and leaves quantizers real headroom. Neither is a workstation model.

The hardware floor, from the vLLM recipe

vLLM's recipe page states the tiers directly: NVFP4 W4A4 needs 8 GPUs — one 8x B300 node or two GB300 trays; FP8 needs 16 GPUs across two nodes, because FP8 requires TP16 minimum; BF16 needs 24 GPUs. Prerequisites are vLLM nightly and transformers 5.4.0 or newer, tensor parallel size must divide the 64 attention heads, and the linear-attention backend is Docker-only until a FlashInfer version upgrade — the same day-0 rough edges K3 had. The low-latency serve command vLLM published:

vllm serve Inferact/Qwen3.8-2.4T-A95B-NVFP4 \
  --tensor-parallel-size 8 \
  --max-model-len 262144 \
  --kv-cache-dtype fp8 \
  --reasoning-parser qwen3 \
  --enable-auto-tool-choice \
  --tool-call-parser qwen3_coder \
  --speculative-config '{"method":"mtp","num_speculative_tokens":3}'

Read that first line again: the 8-GPU path serves a community quantization, not a Qwen artifact. The speculative-config flag is the part K3 could not offer at launch — Qwen shipped its MTP layer in the checkpoint, and vLLM's own guidance is that depth-1 speculation underperforms, so use depth 3. vLLM's published figures — vendor-adjacent, on hardware almost nobody owns — are 304 output tokens per second per user at NVFP4 TP8 with MTP-3, 307 at FP8 TP16, and up to 4,300 total tokens per second per GPU in the NVFP4 high-throughput profile. SGLang has a parallel cookbook entry, and diff any flags against the live recipe before pasting; day-0 parsers churn.

The workstation path exists and it still hurts

Unsloth's GGUF conversions, sized from the repo's own file listing:

Every row is smaller than the K3 equivalent — BF16 compresses more gracefully than pre-quantized MXFP4 — but the 2-bit builds still clear 650 GB, which is not a workstation number. The modification dividend showed up on schedule regardless: within days of release Hugging Face had AMD's Quark MXFP4 build, RedHatAI NVFP4 conversions with REAP-pruned 25% and 50% variants, a 2-bit MLX build for Apple silicon, and FlagRelease INT8 ports targeting Ascend, Hygon and Kunlunxin accelerators. That breadth — none of it possible against a closed endpoint — is the honest argument for open weights at this scale.

The license, read properly

The repo metadata says license: other, license_name: qwen3.8-max — this is not Apache 2.0, whatever the headlines imply. The text is an MIT-style grant — use, copy, modify, merge, sell, deploy, host, fine-tune — with two conditions:

• Attribution gate. If the software or its derivatives are used in a commercial product with more than 100 million monthly active users or USD 20 million monthly revenue, the model name must be prominently displayed in that product's UI. Same shape as K3's clause.
• The $50M gate — and it covers coding assistants. If you or your affiliates run a Model-as-a-Service or an "AI Work Assistant" business with aggregate revenue above USD 50 million over any consecutive 12 months, you need a separate license before any commercial use. The license defines AI Work Assistant as "an independent AI-powered product primarily designed for AI-assisted coding or office productivity" — Qwen's own Qoder and QwenWork are named as examples. Single-purpose tools, assistants in other domains, and AI features inside a non-coding product are carved out. K3's gate stops at MaaS and triggers at $20 million; Qwen's threshold is higher but its scope reaches exactly the product category this model is marketed for. Build a Cursor competitor on these weights and cross $50 million, and you are negotiating with Alibaba.

Internal use that does not expose the model or its outputs to third parties is exempt, and merely relaying requests to someone else's hosted model does not count as MaaS. One claim that circulated on X — that the license prohibits use in the USA, EU, UK and Korea — does not survive reading the file: there is no geographic restriction in it. Questions go to model-business@notice.qwencloud.com.

The 27B is the release most readers should care about

Qwen3.8-27B arrived a day behind Max with none of the caveats: plain Apache 2.0, a dense 27B (27,781,427,952 parameters), 55.6 GB in BF16, and — unlike the open Max checkpoint — a native vision-language model that takes images and video. It keeps the family architecture (64 layers in the same 3-to-1 Gated DeltaNet layout, 262,144 native context extensible to 1M, a trained MTP layer) and it lifts the Max restriction that matters most in practice: thinking can be disabled per request. A 27B dense model quantizes onto a single high-VRAM GPU with routine tooling. If "open Qwen3.8" ever runs on hardware you own, it will be this one — the 2.4T checkpoint is for providers, and the license difference says Alibaba knows it.

The autonomous-coding pitch, and the benchmark table

The launch marketing leads with "10+ days of autonomous coding," and the flagship exhibit is real and inspectable: qwen-code-dev-bot/oh-my-cli, a code-agent CLI the model built and evolved through GitHub issues and PRs — 265 commits, 127 pull requests and 151 issues over roughly 16 days as of July 30, per Alibaba's own account. A public commit trace is more evidence than most launch demos offer, and worth crediting. It is still a vendor showcase on a vendor-designed harness, graded by the vendor; the companion claims — a research-paper reproduction in about five days and 125 GPU-hours, a 500-plus-turn chip-design run — have no third-party replication yet.

Treat the benchmark table the same way. Every number is Alibaba-run, and four of the benchmarks in it are Qwen-authored. Taken at face value it cuts both ways: Terminal Bench 2.1 at 86.6 lands above Claude Fable 5's 84.6 and below GPT 5.6 Sol's 88.8, and PaperBench at 93.0 tops the table — but on its own numbers Qwen3.8-Max trails Fable 5 by 12.3 points on SWE-bench Pro (67.7 vs 80.0) and by 15.3 on FrontierSWE. A vendor table that concedes double-digit gaps on the hardest software-engineering rows is at least honest about where the frontier still is. For how the closed models compare on independent ground, see Fable 5 vs Kimi K3 and the Chinese coding models roundup; for what a 2.8T-class model is like inside an agent harness day-to-day, Kimi K3 as a coding agent is the closest reference.

Self-host, official API, or aggregator

• Official API — correct for essentially everyone. List price is $2.00 per million input, $6.00 output, $0.25 implicit cache reads, with explicit caching at $2.50 per million to create and $0.17 to read on a 5-minute TTL; AINews notes that is a cut from Qwen3.7-Max's reported $2.50/$7.50. The API serves the full product: 1M context by default, vision input, a 131,072-token completion cap. Two gotchas: reasoning_effort defaults to xhigh (levels are xhigh, medium, low) and thinking tokens bill as output at $6; and preserve_thinking is on by default, so multi-turn agent flows should pass reasoning context back rather than stripping it.
• Aggregator — thinner than K3's day-0 spread so far. OpenRouter lists qwen3.8-max at the same $2.00/$6.00/$0.25 but, at the time of writing, from a single upstream provider: Alibaba Cloud International. The many-providers-one-checkpoint story that makes open weights an anti-lock-in play is real here, but younger — watch the model pricing tracker for hosts coming online.
• Self-host — only under constraint: a regulator, an air gap, a residency contract, or a genuine need to modify the weights. At a 16-to-24-GPU floor for the official artifacts, run the arithmetic in the agent cost calculator before believing any break-even someone quotes you; the K3 analysis found published estimates an order of magnitude apart, and nothing about a 4.89 TB BF16 release makes that math friendlier.

Frequently asked questions

Where Backgrind fits

Backgrind is not a model and not an agent. It is a desktop overlay for macOS and Windows that PTY-wraps the CLI you already run — Claude Code, Cursor, Codex, OpenCode, or Qwen Code — and floats it above your other windows, including games running in borderless fullscreen. It pings you when the agent needs a decision or finishes, which is exactly the shape of the long-horizon runs this model is sold on: a task that grinds for hours should not require a human staring at a terminal for hours.

The open-weights angle matters in one specific way: because the same checkpoint can be served by many providers, switching endpoints is a config change in your CLI rather than a migration — and Backgrind never sees that layer. It renders and forwards whatever your CLI does, whether that CLI is pointed at Qwen Cloud, OpenRouter, or your own vLLM cluster. In BYO-CLI mode your agent's content never touches our servers; Live mode (Plus/Pro) answers prompts from a phone or browser. The Fusion council runs your own CLIs on one hard question in parallel when you want a second opinion before committing.

Sources

License text, model card, config.json and file listing: huggingface.co/Qwen/Qwen3.8-2.4T-A95B (repo size, safetensors parameter counts and commit timestamps read from the Hugging Face API), plus the official FP8 repo and Qwen/Qwen3.8-27B. Vendor announcement and case studies: the Qwen blog post linked from the model card and Alibaba Cloud's "Qwen3.8-Max: A New Bar for Coding and Cowork"; the autonomy trace at qwen-code-dev-bot/oh-my-cli. Hardware tiers, serve command and throughput figures: vLLM recipes; SGLang's parallel entry at docs.sglang.io. GGUF sizes computed from the file listing at unsloth/Qwen3.8-2.4T-A95B-GGUF. API pricing and provider list: openrouter.ai/qwen/qwen3.8-max. Timeline, community reaction and the Qwen3.7-Max price comparison: AINews, The Decoder and Digital Applied. All benchmark figures cited are Alibaba-run; four of the benchmarks in its table are Qwen-authored, and no independent replication existed at publication time.