Qwen3.8-Max Open Weights Are Live: The 397GB Floor, the License Catch, and What Your Home Lab Can Actually Do

By RunAIHome Team · 11 min read
qwenlocal-llmmoehardware-guideopen-weightsalibabagpu-cluster

TL;DR: Alibaba shipped the Qwen3.8-Max weights on August 12, 2026 — Qwen/Qwen3.8-2.4T-A95B on Hugging Face, a 2.4-trillion-parameter MoE with 95B active parameters and 512 experts. Three things the r/LocalLLaMA victory lap glossed over: the license is not Apache 2.0 (it’s a custom license with a $50M revenue trigger), the open checkpoint is text-only (the multimodal Max lives behind the API), and the smallest GGUF anyone has produced is 397GB at 1-bit. No consumer machine is in this conversation. The interesting question is what the drop tells you about where the ceiling is — and the answer for your actual hardware budget hasn’t changed.

Rent the FP8 clusterUse the APIRun Qwen3.8-27B locally
Hardware24× H200 (3-node)NoneOne used 24GB card
Cost~$103/hr on RunPod Instant Clusters (our arithmetic: 24 × $4.31)$2/M input, $6/M outputUsed RTX 3090, ~$1,264
What you getFull weights, your data stays on your podsMultimodal, 1M context, built-in tools~41 tok/s at Q4_K_M, yours forever
Who it’s forCompanies with a compliance reasonEveryone evaluating MaxEvery home lab reading this

Honest take: This release matters as a precedent — a frontier lab’s flagship-class model with downloadable weights, day-0 vLLM support, and vendor-verified 4-bit checkpoints for both NVIDIA and AMD. It does not matter as a thing you will run. Even the 1-bit GGUF outweighs the biggest RAM build we’ve ever covered, and the per-hour cluster math loses to the API at any usage level a home lab can generate. Download nothing; run the 27B from the same release instead.

What actually shipped on August 12

When we covered Qwen3.8-Max as a preview in July, Alibaba had published exactly one number: 2.4 trillion total parameters. No active-parameter count, no license, no date. The weight drop fills in the blanks:

  • Qwen/Qwen3.8-2.4T-A95B — BF16 safetensors, roughly 4.9TB on disk (Unsloth’s measurement)
  • Qwen/Qwen3.8-2.4T-A95B-FP8 — fine-grained FP8 (block size 128), ~2.4TB by weight arithmetic (2.4T params × 1 byte; our math)
  • 95B active parameters per token, 512 experts — confirmed by the vLLM team’s day-0 announcement, which called it one of the largest open-weight models released to date
  • Native context of 262,144 tokens, extensible toward ~1M — down from the API’s 1M default (llm-stats teardown)
  • Day-0 serving support in vLLM, SGLang, and Transformers, verified on both NVIDIA and AMD hardware

You can confirm the repo is live without downloading a byte — the same check we used for the GLM-5.3 weight watch:

$ curl -s -o /dev/null -w "%{http_code}\n" \
  https://huggingface.co/Qwen/Qwen3.8-2.4T-A95B/resolve/main/config.json
200

Two subtractions from the API product hide in the model card. The open checkpoint is text-only — the vision and video input that define hosted Qwen3.8-Max stayed behind the API. And thinking mode is required-on: the checkpoint always reasons before answering, where the API gives you a toggle. If your use case was “the multimodal Max, but on my hardware,” this drop is not that.

The license is the actual news

The queue of hot takes calling this an Apache 2.0 release is wrong, and it matters. The repo carries a custom “Qwen3.8-Max License” (full text on Hugging Face) — a first for a Qwen flagship, and stricter than anything Alibaba has attached to the 3.x line.

The terms that matter, per the South China Morning Post’s report and the license text:

  • Internal use is exempt. Run it inside your company (or your basement) all you want, as long as the model’s outputs aren’t offered to third parties.
  • Commercial “model as a service” and “AI work assistant” products need a separate license once revenue exceeds $50 million in any consecutive 12 months.
  • The user threshold is 100 million MAU — seven times lower than the 700-million-user line Meta drew on Llama 2 and Llama 3.

For a home lab, none of this bites — you’re the internal-use exemption personified. But it breaks the pattern that made Qwen the default base-model family for fine-tuners: Qwen3.8-27B shipped two days later under Apache 2.0, while the Max got a leash. If you’re building anything you might someday sell, the 27B is the one with a clean deed.

Every checkpoint, sized

The full menu as of August 25, 2026:

FormatSizeSourceMinimum sensible hardware
BF16 safetensors~4.9TBQwen (official)Multi-node H200/B300 cluster
FP8 (block-128)~2.4TBQwen (official)24× H200 across 3 nodes (vLLM recipe)
NVFP41.32 TiBInferact, vendor-verified8× B300 node (NVIDIA blog)
MXFP41.45 TiBInferact, vendor-verified8× AMD MI355X node
GGUF IQ1_S508GBUnsloth512GB+ RAM server, if you insist
GGUF UD-TQ1_0 (1-bit dynamic)397GBUnslothThe floor. There is nothing below this.

Read the bottom two rows again. The smallest artifact of this model that exists — a 1-bit quant, 91% smaller than the original — is 397GB. For calibration against the other cloud-class open models we’ve measured:

ModelTotal / active paramsSmallest usable quantHome-lab entry point
MiniMax M3428B / 23BQ2_K_XL ~143GB192GB RAM build, painful
GLM-5.2744B / 40BUD-IQ1 ~217GB24GB GPU + 192GB RAM, 3–6 tok/s
Kimi K32.8T / 104B1.56TB native MXFP4None — 8 GPUs is the floor
Qwen3.8-Max2.4T / 95B397GB at 1-bitNone that we’d defend

Qwen3.8-Max lands between GLM-5.2 and Kimi K3, and on the wrong side of the line for a RAM build. A 397GB working set means a 512GB DDR5 server — and DDR5 is exactly what the DRAM crisis repriced hardest this year. Then physics takes over: 95B active parameters per token is more than double GLM-5.2’s 40B, and GLM-5.2’s 1-bit quant already crawls at 3–6 tok/s on a 24GB-GPU-plus-192GB-RAM rig. We haven’t found a single published community tok/s measurement for the Max GGUFs on CPU-offload hardware as of August 25 — which, thirteen days after release, is itself the data point. The people who own the hardware to try it are serving FP8 on clusters instead.

And no, the Mac path is gone: Apple stopped selling Mac Studio configurations above 96GB this spring, so there is no current single-box unified-memory machine that even fits the 1-bit file.

The context-length trap, even on a cluster

Here’s the problem-and-fix that tells you how heavy this model really is. The official vLLM recipe for the FP8 checkpoint on a 3-node, 24× H200 cluster — that’s 3.38TB of pooled VRAM — launches like this:

vllm serve Qwen/Qwen3.8-2.4T-A95B-FP8 \
  --tensor-parallel-size 24 \
  --enable-expert-parallel \
  --gpu-memory-utilization 0.9 \
  --max-model-len 32768

Note the last flag. The model’s native context is 262,144 tokens, but the reference deployment caps it at 32,768 — because after ~2.4TB of weights, what’s left of 3.38TB has to hold the KV cache for every concurrent request, and 95B-active attention at 262K context would blow through it. Naively raise --max-model-len to the native 262144 and vLLM fails at engine init with a KV-cache allocation error (the same failure mode we walked through in vLLM Won’t Start?). The fix is the one in the recipe: cap the context, or add nodes. When 24 Hopper GPUs have to ration context length, “extensible to 1M” is a spec-sheet number, not a deployment plan.

What it costs to actually run

RunPod lists the H200 SXM at $4.31/GPU/hour on Instant Clusters (RunPod pricing, August 2026). The reference FP8 deployment therefore rents for about $103/hour, or roughly $2,480 per day (our arithmetic: 24 × $4.31 × 24h) — spin one up here if you have a genuine reason to hold the weights yourself.

Against that, the hosted API charges $2 per million input tokens and $6 per million output — and the API version is the better product (multimodal, 1M context, optional thinking). One hour of cluster rental buys you 17M output tokens at API rates. Unless you’re pushing sustained multi-million-token-per-hour throughput or your data legally cannot leave your infrastructure, the API wins every time — the same rent-vs-buy conclusion this site keeps reaching, at 100× the usual scale.

The benchmark picture, for what it’s worth this early: Yotta Labs’ verification roundup puts Qwen3.8-Max at 67.7 on SWE-bench Pro — about 12 points behind Fable 5 — with agentic-workflow scores (OSWorld-Verified 86.1) that lead the open-weight field. Treat all of these as API-tier numbers; nobody is benchmarking the 1-bit GGUF.

What your home lab should do instead

The same August release wave included Qwen3.8-27B — Apache 2.0, a ~17GB Q4_K_M, and a measured ~41 tok/s on a used RTX 3090. That’s the model this drop actually delivers to your desk. The used 3090 at ~$1,264 remains the entry ticket to the 27B class, and our 24GB VRAM model guide covers what else that card unlocks.

If your interest in Max is coding-agent work, the calculus is the same one we ran for Kimi K3: use the API for the frontier model, keep a local 27B for the 80% of tasks that don’t need it, and let the BYOK setups on our sister site aicoderscope.com glue the two together. For the self-hosting side of serving smaller Qwen models properly, aifoss.dev covers the FOSS stack.

The precedent is still worth something. Eighteen months ago, “open weights” topped out around 400B parameters; now two of the three largest models Chinese labs ship come with a download link, day-0 inference-engine support, and vendor-verified 4-bit builds for both GPU camps. Every technique that trickles down from serving these monsters — expert parallelism, FP4 formats, KV-cache rationing — eventually lands in llama.cpp within a year. The 2.4T model isn’t for you. The tooling it forces into existence will be.

FAQ

Is Qwen3.8-Max open source? The weights are downloadable, but the license is a custom one, not OSI-approved open source. Internal use is unrestricted; commercial AI services built on it need a separate license past $50M revenue or 100M MAU. Qwen3.8-27B, released the same week, is genuine Apache 2.0.

Can I run Qwen3.8-Max on a 512GB RAM server? The 397GB 1-bit GGUF technically fits, but no community speed measurements exist yet, and extrapolating from GLM-5.2 (which has less than half the active parameters and manages 3–6 tok/s at 1-bit on comparable hardware) puts the Max deep into seconds-per-token territory. 1-bit quantization of a model this sparse also costs real quality. We don’t recommend the attempt as anything but a stunt.

Why is the open checkpoint text-only when the API is multimodal? Alibaba hasn’t said. The pattern matches the context-window cut (262K native vs 1M hosted): the open drop is the language core, and the differentiated product features stay behind the API.

What’s the cheapest way to try Qwen3.8-Max? The API, at $2/M input and $6/M output through Alibaba or OpenRouter. A few dollars covers a serious evaluation. Renting the 24× H200 reference cluster costs ~$103/hour and makes sense only for sustained production loads with data-residency requirements.

Does this release change what GPU I should buy? No. Nothing below a datacenter node runs any version of this model, so the used-GPU math from our buying guides is untouched: a used RTX 3090 for the 27B–35B class, or a 12–16GB card for the tiers below it.

Sources

Last updated August 25, 2026. Prices, checkpoint availability, and license terms change; verify current rates before purchasing or deploying.

Was this article helpful?