# Qwen4-Max: the same 2.4 trillion parameters, spent on a different machine

> Satyajit Ghana — Head of Engineering @ Inkers Technology
> canonical: https://ai.satyajit.si/articles/qwen4-max
> date: 2026-11-16
> tags: qwen, mixture-of-experts, sparse-attention, linear-attention, benchmarks, agents

Alibaba released [Qwen4-Max](https://qwen.ai/blog?id=qwen4-max) this morning, Beijing time. The [launch thread](https://x.com/Alibaba_Qwen/status/2122148127520289151) is four lines of highlights, a benchmark grid, three videos and a promise: "The open weights of smaller Qwen4 models will be released." The model itself is an API on [QwenCloud](https://www.qwencloud.com/models/qwen4-max), at \$1.50 per million input tokens and \$4.50 per million output.

There is no technical report and no checkpoint. What there is: one paragraph of architecture, a diagram, a loss curve, a base-model bits-per-byte chart, a 16-panel post-training chart, a token-efficiency chart, a price list, and about two thousand words of case studies. That is enough to work with, in this order.

First, the architecture. The paragraph is short, but it describes a design that is already public. In August Qwen shipped [Qwen3.8-Flash-Next](/articles/qwen3-8-flash-next) with open weights and a 28-page report, and called it an early preview of the Qwen4 architecture. Its `config.json` has every width the Qwen4-Max blog leaves out. So I can explain the mechanism from a file, then mark exactly which numbers carry over and which do not.

Second, the benchmarks. Qwen4-Max is compared against Opus 5.5, GPT-6.1 Sol, GPT-6 Astra and Kimi K3.1. I checked every comparator bar against a source that is not Qwen's: Moonshot's own model card, Anthropic's own launch page, Artificial Analysis, and the benchmarks' public leaderboards.

Third, the money. "Average cost per task drops over 60%" is a claim about tokens and prices together. The prices are public, the token counts are on a chart, and the two can be solved for what the claim implies.

| | Qwen4-Max | Qwen3.8-Max (previous) |
|---|---|---|
| Backbone | **2.4T** parameters | 2.4T |
| Active per token | **71B** | 95B |
| N-gram embedding | **328B**, extra, at layer 2 | none |
| Attention | 3 Gated DeltaNet : 1 Qwen Sparse Attention | 3 Gated DeltaNet : 1 gated attention |
| Residual | Gated Residual, 4 lanes | one stream |
| Context | 1M (991K input, 131K output, 262K output when thinking) | 1M (991K input, 131K output) |
| Input | text, image, video | text, image, video |
| Price, per 1M tokens | **\$1.50** in, **\$4.50** out, **\$0.075** cached | \$2 in, \$6 out, \$0.25 cached |
| Weights | none; API only | open, custom `qwen3.8-max` licence |

The Qwen4-Max column is the blog and the [QwenCloud model page](https://www.qwencloud.com/models/qwen4-max); the Qwen3.8-Max column is its own [model page](https://www.qwencloud.com/models/qwen3.8-max) and [what its weights showed](/articles/qwen3-8-open-weights) when they landed in August. The context and output limits are the model pages', read today.

## The same 2.4 trillion, spent differently

The first number in the blog is the one people will repeat: 2.4 trillion parameters. The [previous flagship](/articles/qwen3-8-max) launched in August with the same number. It is also the least informative, because Qwen3.8-Max was 2.4 trillion parameters too. What changed is how many of them a token touches and what else sits beside them.

Qwen3.8-Max activated 95B per token, so about one parameter in 25 did work for any given token. Qwen4-Max activates 71B, one in 34. The blog states the change itself: "activating 25% fewer parameters", and 71 against 95 is a 25.3% drop. A mixture-of-experts model gets this ratio by keeping many experts and routing each token to a few. The more experts sit idle per token, the more capacity you hold per unit of compute, and the more memory you need to hold it.

Put next to the models on Qwen's own base-model chart, the trend is clear. Those labels give each model as active over total: GLM-5.3 at 40B of 744B, DeepSeek-V4-Pro-Base at 49B of 1.6T, Kimi-K3.1-Pro at 104B of 2.8T, Qwen3.8-Max at 95B of 2.4T. Qwen4-Max at 71B of 2.4T is the sparsest of the five by that measure. DeepSeek's 1.6T over 49B is close behind, at about one in 33.

Then there is the 328B. The blog says "an additional 328B N-gram Embedding parameters", and the word "additional" matters: they are not in the 2.4T and not in the 71B. They are a lookup table. I come back to it below, because it is the part of this model that most changes what serving it costs.

How do you find out more than the blog says? You read the open model built the same way.

<Figure
  src="https://media.thesatyajit.com/ai/articles/qwen4-max/fig1.png?v=4fbd37529c4edd8c"
  alt="The Qwen4-Max architecture diagram. Input tokens feed a vocabulary embedding and, separately, an N-gram embedding layer marked 'Layer 2 only' that joins at the second GDN layer. The stack repeats three GDN layers and one QSA layer. An expanded view shows a GDN layer (3x) and a QSA layer (1x): each has a four-slot expanded residual; GR Read takes a hidden state from it into Gated DeltaNet or Qwen Sparse Attention, GR Write puts the result back, then GR Read feeds a MoE block and GR Write again. At the top a final GR Read feeds the prediction head, and MTP modules sit beside it."
  caption="Three GDN layers and one QSA layer per group, four residual slots read and written through gates, an N-gram table entering at layer 2, MTP modules at the top. It is the same drawing as Qwen3.8-Flash-Next's, with the repeat counts written in. (Qwen, Qwen4-Max blog, Figure 3.)"
/>

That diagram is, line for line, the one Qwen published for Flash-Next in August. Flash-Next's checkpoint declares `Qwen4ExpForConditionalGeneration`, and the public vLLM code for it lives in a package called `qwen4_exp`. Our [Qwen4-27B piece](/articles/qwen4-27b-vllm-xpu) traced that naming when a kernel PR leaked a dense 27B built the same way. So the honest framing is this: Qwen4-Max is the first flagship built on an architecture whose small version has been open for three months.

<ModelCard repo="Qwen/Qwen3.8-Flash-Next" />

Here is what Flash-Next's `config.json` says, and what I can and cannot carry across.

| `config.json` key (Flash-Next) | value | Qwen4-Max |
|---|---|---|
| `full_attention_interval` | 4 | same, stated: "Three Gated DeltaNet layers ... for every QSA layer" |
| `hc_count` | 4 | same, stated: "Four parallel residual branches" |
| `ple_layer_ids` | `[2]` | same, stated: "at the second layer" |
| `ngram_size` | 3 | not stated |
| `indexer_compress_ratio`, `indexer_budget` | 4, 2,048 | not stated; "micro-block granularity" only |
| `num_experts`, `num_experts_per_tok` | 512, 10 | not stated |
| `num_hidden_layers`, `hidden_size` | 48, 2,560 | not stated |
| `mtp_num_hidden_layers` | 1 | diagram says "MTP Modules", plural |
| `max_position_embeddings` | 262,144 | 1M served |

Three rows are confirmed by the blog's own words. The rest are Flash-Next's and may or may not have changed. When I use Flash-Next's shapes below to make the mechanism concrete, I say so.

## Why three of every four layers forget on purpose

A transformer layer with full attention pays twice for a new token at position $L$. It compares the token's query with every one of the $L$ stored keys, and it keeps those keys and values in a cache that grows by one entry per token, forever. Both costs are linear in $L$ per token, so quadratic over a sequence. At a million tokens that is the whole problem.

A linear-attention layer replaces the growing cache with a fixed-size state. Gated DeltaNet, the variant Qwen uses, keeps a matrix $S_t$ per head and updates it like this:

$$
S_t = \alpha_t \, S_{t-1}\left(I - \beta_t \, k_t k_t^\top\right) + \beta_t \, v_t k_t^\top
$$

Read it right to left. $v_t k_t^\top$ is the new association: this key should retrieve this value. $\beta_t$, between 0 and 1, is how hard to write it. The $(I - \beta_t k_t k_t^\top)$ term first erases whatever the state already returned for $k_t$, so writing a key that is already there corrects it instead of piling a second copy on top. $\alpha_t$, also between 0 and 1, decays the whole state, and it is gated: the layer learns when to forget. Reading is $o_t = S_t q_t$, a single matrix-vector product, the same cost at token ten as at token ten million.

Where any fixed-size memory fails is exact recall. A state of fixed width cannot store a million distinct key-value pairs without interference. If the task is "find the clause on page 400 that defines the indemnity cap", a compressed summary of the first 399 pages may simply not contain it. So Qwen keeps one layer in four as real attention, which can go back and read the exact tokens.

That fourth layer is where Qwen's own idea comes in. Ordinary sparse attention does not read all $L$ tokens; it picks a budget of them with a cheap scorer, an indexer, and attends only to those. But the indexer still scores every token, so it is still linear in $L$, just with a smaller constant. At a million tokens, Flash-Next's report argued, the choosing costs more than the reading. **Qwen Sparse Attention** compresses before it indexes: the indexer scores micro-blocks of tokens instead of single tokens (four tokens a block in Flash-Next), then picks blocks up to a budget (`indexer_budget: 2048` in Flash-Next's config, which I read as tokens; the config does not say whether it counts tokens or blocks) and attends inside them. The blog's sentence for Qwen4-Max says the same thing: it "uses a lightweight indexer to select relevant context at micro-block granularity, reducing both attention and indexing costs".

Put numbers on one layer group. With Flash-Next's shapes (24 query heads of width 256, two KV heads; an indexer of four heads at width 128; GDN states of 48 heads at 128 by 128), the attention arithmetic for one new token in one group of four layers is:

- four full-attention layers: $4 \times 2 \times 24 \times 256 \times L = 49{,}152\,L$ multiply-adds;
- the hybrid: an indexer scan of $128\,L$, attention over at most 2,048 selected tokens, and three GDN state updates that do not depend on $L$ at all.

At 128K tokens that is about 6.4 billion multiply-adds against about 49 million, 131 times less. At 1M it is about 310 times less. Past the 2,048-token budget the only term still growing with $L$ is the indexer's $128\,L$, and that is what the micro-block compression shrank fourfold.

<LayerCost />

The memory picture is less dramatic, and the widget's second tab is there to say so. QSA chooses what to read, not what to keep: every token's key and value still has to be stored, because the indexer might pick any block later. So the QSA layer's cache grows exactly like full attention's, plus a little for the indexer's compressed keys. The saving is the three GDN layers, whose state is fixed at 3 MiB each in fp32 with Flash-Next's shapes. Net, one group holds about 3.9 times less cache at 1M than four full-attention layers would. That is a real saving, and it is not a constant-memory model.

Flash-Next's report also measured what the compression costs in quality, and that measurement is the best evidence available for Qwen4-Max's long-context behaviour, since the blog publishes none. On 8-needle MRCR, QSA trailed full attention by 1.16 points at 128K and 1.20 at 256K, then led by 9.87 at 512K and 5.73 at 1M. A small loss at moderate length, a gain at long length. I would expect the same shape at Qwen4-Max's scale and I cannot check it: the blog has no long-context benchmark at all, which is an odd omission for a model whose headline includes a one-million-token window.

## Four residual lanes, gated

In an ordinary transformer every layer adds its output to one running vector, the residual stream. Everything any layer wants to tell any later layer goes through that one vector, and early features get diluted by everything written after them.

Gated Residual widens the stream to four lanes. Before each sublayer (the attention or DeltaNet, then the MoE), a read gate mixes the four lanes into the single hidden state the sublayer consumes. After it, a write gate distributes the sublayer's output back across the four lanes. Both gates depend on the data, so a layer can choose to read mostly from lane 3 and write mostly into lane 1. In the diagram that is every GR Read and GR Write box. The blog's one-line description is "Four parallel residual branches use dynamic read and write gates to strengthen information flow across layers and improve training stability."

This is the hyper-connection idea with one operator removed. The original hyper-connections, and [GLM-5.3](/articles/glm-5-3)'s variant of them, also mix the lanes into each other at every layer. Flash-Next's report ablated that mixing operator and found that deleting it cost nothing while removing memory traffic. I said in the Flash-Next article that this question is open, and nothing in the Qwen4-Max blog closes it. What the Qwen4-Max blog adds is the stability claim at scale, covered with the training run below.

What it costs is kernel work, not arithmetic. Four lanes means every block reads and writes four times the residual width. When LMSYS brought Flash-Next to SGLang, the fused mix kernel went from 12.36 µs to 6.03 µs on B300 and was worth 7.6% end to end. A 2.4T model with the same four lanes needs those kernels just as badly. Since the model only runs on Alibaba's servers, that is Alibaba's problem, and the price list is where you would see it.

## A 328B table that costs almost no compute

The third change is the one I find most interesting, because it changes where a model's parameters live.

An N-gram embedding is a second embedding table indexed not by the current token but by the current token together with the tokens just before it. Flash-Next uses trigrams (`ngram_size: 3`). The lookup key is a hash of a short window, the table returns a vector, and that vector is added into the hidden state at layer 2. The blog: "Context-based lookups provide representations of local token patterns at the second layer, expanding model capacity with little additional computation."

The arithmetic is why it is attractive. A lookup is a gather, not a matrix multiply, so it adds almost no FLOPs. And because the index depends only on the input tokens, it is known before the forward pass reaches layer 2. You can keep the table in host memory, compute which rows the next tokens need, and prefetch them while layer 1 runs. Flash-Next's table was sized exactly like that: `ngram_vocab_size_base` of 20 million rows times `ple_embed_dim` of 2,560 is 51.2 billion parameters, which is the 51B the report quotes.

At Qwen4-Max's 328B the table is 6.4 times Flash-Next's, though the backbone grew about 19 times (125B to 2.4T), so relative to the backbone the table shrank, from about 41% of it to about 14%. Stored in BF16 that is 656 GB; in FP8, 328 GB. My arithmetic, not Qwen's. For comparison, the whole 2.4T backbone in FP8 is about 2.4 TB, so the table is roughly an eighth again on top. Nobody puts 656 GB of lookup table in GPU memory if they can avoid it, and they can: SGLang showed for Flash-Next that each token touches only 16 rows, kept the table in pinned host memory, gathered rows with a UVA kernel overlapped with the first block, and lost 0.07% of throughput while freeing 23.46 GiB per GPU and gaining 78.54% more KV-cache room. Qwen's serving stack is not public, so I cannot say Qwen4-Max is served that way. It would be strange if it were not.

Does the table pay for itself? Flash-Next's report was candid about it. Training loss fell steadily with table size, but downstream benchmarks peaked early and partly fell back, except Chinese benchmarks, which kept improving. In a fixed-budget comparison, trading experts for table parameters showed "no clear improvement over the MoE-only baseline." That was at 51B. Qwen4-Max scales the table six-fold in absolute terms and shrinks it relative to the backbone, and the blog explains neither choice. The base-model chart below improves most on knowledge, which is at least consistent with a large memory of local patterns. It is not an ablation, and I would not call the table justified on the evidence published.

## The training run, and what is not in the blog

On training, the Qwen4-Max blog is brief. The run reached 2.4T "smoothly, with loss decreasing steadily and no loss spikes throughout the run." It attributes this to "improvements in model architecture and training optimization." And the base model has the lowest bits per byte of five checkpoints on Qwen's in-house evaluations.

<Figure
  src="https://media.thesatyajit.com/ai/articles/qwen4-max/fig5.png?v=7b7737a3f80b03fd"
  alt="A training-loss curve against training progress from 0% to 100%. Loss starts near 1.80, drops steeply to about 1.20 by around 5%, then declines slowly to about 1.04 at 100%. The band is narrow throughout; two single-step blips are visible, one near 10% and a smaller one near 75%."
  caption="The run's loss, no axis for tokens or steps. Look closely and there are two single-step blips, near 10% and near 75%, which the blog does not count as spikes; they recover within the line's width. (Qwen, Qwen4-Max blog, Figure 4.)"
/>

A loss curve with no x-axis units is a picture of a mood. It does show a well-behaved run, and the two tiny excursions I can see are not the divergence-and-rollback events that "loss spike" usually means. What it does not tell you is how many tokens, what data, what mix of languages and code, what context-length schedule, or what optimiser. For Flash-Next the report answered all of that: Muon on the matrix-shaped parameters with AdamW on embeddings, router and gate parameters, fused projections split before orthogonalisation, no batch-size warmup. It is a fair guess the flagship shares that recipe. It is a guess.

<Figure
  src="https://media.thesatyajit.com/ai/articles/qwen4-max/fig4.png?v=4be2ea46aed3475d"
  alt="Four bar charts of ten times bits per byte, lower is better, for Knowledge, Code, QA and STEM. Models: Qwen3.8-Max-Base (95B/2.4T), GLM-5.3 (40B/744B, post-trained), DeepSeek-V4-Pro-Base (49B/1.6T), Kimi-K3.1-Pro (104B/2.8T, post-trained) and Qwen4-Max-Base (71B/2.4T). Knowledge: 5.60, 5.87, 5.07, 4.88, 4.86. Code: 1.88, 1.90, 2.04, 1.83, 1.67. QA: 3.10, 3.20, 3.67, 3.04, 2.94. STEM: 3.04, 3.24, 3.23, 2.74, 2.70."
  caption="Base-model bits per byte on Qwen's in-house sets. Qwen4-Max-Base is lowest in all four, against Kimi-K3.1-Pro by 0.02 on Knowledge and 0.04 on STEM. Two of the five are post-trained models, which the chart marks with an asterisk. (Qwen, Qwen4-Max blog, Figure 5.)"
/>

Bits per byte is a good choice of metric here, because it normalises away the tokenizer: a model with a bigger vocabulary cannot look better by spending fewer tokens on the same text. Against its predecessor the drop is 13.2% on Knowledge (5.60 to 4.86), 11.2% on Code (1.88 to 1.67), 5.2% on QA (3.10 to 2.94) and 11.2% on STEM (3.04 to 2.70), my arithmetic on the bar labels, which matches the blog's "approximately 5–13%".

Two caveats from the chart itself. The evaluation sets are in-house, so nobody outside Qwen knows how close they sit to Qwen's pre-training data, and a base model scores better on text it has nearly seen. And the closest rival, Kimi-K3.1-Pro, is a post-trained chat model, which the caption admits "may affect comparisons with base models." Post-training usually raises perplexity on generic text, so if anything that flatters Qwen. The margin over Kimi on Knowledge is 0.02.

Post-training gets even less. The blog describes Work360, a taxonomy of 26 domains, 182 subdomains and 721 fields used to build tasks, and "Model-Harness-Product CoDesign" with the Qoder team. There is no description of the reinforcement-learning setup, the reward models, the number of environments, or the effort levels beyond their names. The cost chart below shows Low, High and Xhigh, so the model has at least three reasoning efforts. On Qwen3.8-Max, the open weights showed `reasoning_effort` was implemented as two English sentences in the chat template. Whether Qwen4-Max's is the same, nobody outside Alibaba can see.

The safety section has the most specific post-training numbers in the post. Qwen says it added security checks to the reward for coding tasks, not only functional checks. On "Last Secure Code Bench", the share of function-level code that both works and is secure rose from 22.0% to 31.8%, and code generated securely "at all three granularities", function, file and repository, rose from 8% to 14.7%. For cyber it filtered training data by purpose, keeping defensive tasks and removing offensive ones, and reports that internal experts reviewing full chain-of-thought found "no capabilities posing large-scale cybersecurity risks". I have no way to check any of that. Note only the honest framing of the coding number: fewer than a third of functions pass both bars.

## Sixteen panels, checked one bar at a time

<Figure
  src="https://media.thesatyajit.com/ai/articles/qwen4-max/fig2.png?v=449d521d176729f2"
  alt="Sixteen bar-chart panels comparing Qwen4-Max, Qwen3.8-Max-0902, Opus 5.5, GPT-6.1-Sol, GPT-6-Astra and Kimi K3.1. Values, in that order: DeepSWE v1.1 75.7, 69.3, 74.2, 75.2, 74.1, 75.5. CodeArena Elo 1750, 1676, 1816, 1742, 1763, 1686. Terminal-Bench 4.0 48.5, 38.9, 59.6, 56.1, 59.1, 67.2. ProgramBench 31.5, 28.0, 65.0, 52.5, 55.0, 25.0. AA-Briefcase v1.1 Elo 1686, 1605, 1801, 1555, 1569, 1674. Agents' Last Exam v1.1 46.7, 27.9, 43.4, 42.6, 43.4. JobBench 68.5, 65.3, 75.4, 66.2, 66.1, 61.2. APEX-Agents v1.1 72.1, 63.3, 73.5, 60.0, 64.7, 65.5. HLAB-Vals-1.1 21.3, 15.4, 9.2, 6.3, 7.1, 11.7. AutomationBench-AA 72.5, 56.2, 69.5, 64.9, 68.5, 73.3. AgentArena net improvement 7.5, 18.2, 11.8, 13.9, 3.9. BioMysteryBench 85.0, 84.1, 81.9, 84.4, 78.9, 80.6. HealthBench Professional 60.0, 39.6, 59.9, 65.1, 66.0, 57.2. Humanity's Last Exam 51.7, 43.9, 59.8, 54.0, 53.6, 51.1. Chartography 54.2, 42.0, 66.3, 67.8, 71.1, 50.0. Video-Index 68.1, 63.2, 74.8, 73.8, 76.7, 63.2."
  caption="The launch chart. Qwen4-Max's value is bold in every panel, including the ones it does not lead. (Qwen, Qwen4-Max blog, Figure 1.)"
/>

The first thing to do with a chart like this is count. Qwen4-Max has the highest bar in four of sixteen panels: DeepSWE v1.1 (75.7, by 0.2 over Kimi), Agents' Last Exam v1.1 (46.7), HLAB-Vals-1.1 (21.3) and BioMysteryBench (85.0). In the other twelve, at least one comparator is higher, usually Opus 5.5. Qwen's caption claims a step up from Qwen3.8-Max "across nearly every capability", and that part is true: it beats its predecessor in all fifteen panels that have a Qwen3.8-Max bar. It does not claim to lead the field, and on its own chart it does not.

The second thing is provenance. A comparison chart is only like-for-like if the numbers in a row were made the same way. There are three ways to fill a comparator bar: run the model yourself, copy the other lab's self-reported number, or copy a third party who ran everyone. Each is legitimate. Mixing them inside one row is where charts mislead. So I went row by row.

<BenchAudit />

What I found, in order of how much it matters.

**Terminal-Bench 4.0 is Artificial Analysis's run, not the labs' numbers.** Qwen shows Opus 5.5 at 59.6, GPT-6 Astra at 59.1 and Kimi K3.1 at 67.2. Anthropic's own [Opus 5.5 launch page](https://www.anthropic.com/news/claude-opus-5-5) reports Opus at 66.4% and Astra at 57.9%. Moonshot's [Kimi-K3.1-Pro card](https://huggingface.co/moonshotai/Kimi-K3.1-Pro) reports Kimi at 65.7. None of those match. Then I read the data behind [Artificial Analysis's Qwen4 Max page](https://artificialanalysis.ai/models/qwen4-max), which stores a `terminalBench40` score per model: 0.596 for Opus 5.5 (max), 0.591 for Astra (max), 0.561 for GPT-6.1 Sol (max), 0.672 for Kimi K3.1 Pro, and 0.485 for Qwen4 Max. Every comparator bar in Qwen's panel is AA's number to the decimal, and Qwen4-Max's own 48.5 equals AA's 0.485 as well as the Xhigh point on Qwen's own token chart.

Is that a problem? It makes the row more comparable, not less: one harness, one grader, all five models. The issue is labelling. The blog's footnotes list which rows are "cited from the Artificial Analysis" and name only AA-Briefcase and AutomationBench-AA. A reader who checks Anthropic's 66.4 against Qwen's 59.6 will conclude Qwen understated Opus by seven points. It did not; it used a different, consistent source and did not say so. The same row tells you something real: in a neutral harness, Qwen4-Max is 19 points behind Kimi K3.1 Pro, an open-weight model, on terminal work.

**ProgramBench has two bars that disagree with Moonshot's card.** Qwen shows Opus 65.0, Astra 55.0, Kimi 25.0, Qwen4-Max 31.5. Moonshot's card shows Opus 65.0, Astra 50.0 and Kimi 31.5. Opus matches. Astra is five points higher on Qwen's chart than on Moonshot's, and Kimi is 6.5 points lower. Moonshot's footnote says its ProgramBench scores are binary (a task counts if it reaches 95%) and that its non-Kimi scores come from Vals AI. The [Vals AI leaderboard](https://www.vals.ai/benchmarks/programbench) today headlines a different number again: Opus 5.5 at 18.50% accuracy. ProgramBench clearly has more than one scoring rule in circulation, and Qwen's footnotes do not say which it used or where the comparator numbers came from. The coincidence that Qwen4-Max's 31.5 equals Kimi's self-reported 31.5 exactly is probably just that. I would not lean on this row in either direction.

**APEX-Agents is clean for the comparators, self-run for Qwen.** Qwen's footnote says the scores are "cited from the Mercor leaderboard". I read [Mercor's leaderboard](https://www.mercor.com/apex/apex-agents-leaderboard/): Opus 5.5 at 73.5%, Kimi K3.1 Pro at 65.5%, GPT-6 Astra at 64.7%, Qwen3.8-Max at 63.3%, GPT-6.1 Sol at 60.0%. All five match Qwen's bars. Qwen4-Max is not on the board yet, so its 72.1 is Qwen's own run. Two side notes. Moonshot's card claims 69.4 for Kimi, four points above what Mercor shows (our [Kimi K3.1 Pro article](/articles/kimi-k3-1-pro) traced how that card's APEX row was revised), so Qwen used the more conservative public number for a rival. And Artificial Analysis's page data carries an `apexAgents` field of 0.591 for Qwen4 Max, which is not 72.1; I cannot tell from the page whether AA measures the same metric as Mercor's mean score, so I note it and do not lean on it.

**Agents' Last Exam matches the board, with a model missing.** The [ALE v1.1 leaderboard](https://agents-last-exam.org/leaderboard) has "Qwen 4" first, in the Codex harness at XHigh: 46.7% pass rate, 74.4% score, 185 hours of runtime and 13.6M output tokens across the 122 tasks. Kimi 3.1 Pro (Kimi Code, Max) and Opus 5.5 (Claude Code, Max) are at 43.4% and Astra (Codex, Max) at 42.6%, as Qwen shows. Second on the board, at 45.9%, is Gemini 4 Carbon, which is not on Qwen's chart at all. Every panel on the chart omits Google. That is a choice of comparators, not an error, and it is worth knowing when you read "outperforms".

**DeepSWE, AutomationBench-AA, BioMysteryBench, AA-Briefcase and HLE match.** Opus, Astra and Kimi's DeepSWE values (74.2, 74.1, 75.5) are exactly Moonshot's card. AutomationBench-AA (69.5, 68.5, 73.3) matches Moonshot's card and AA. BioMysteryBench (81.9, 78.9, 80.6) matches Moonshot's card. AA-Briefcase matches AA's page today (Opus 1801, Qwen4 1686, Kimi 1674, Astra 1569, Sol 1555); Moonshot's card from three weeks ago had Opus at 1803 and Kimi at 1678, the normal drift of an Elo rating. Humanity's Last Exam uses the no-tools setting, and Opus 59.8, Astra 53.6 and Kimi 51.1 are Moonshot's HLE-Full row. Anthropic headlines 67.7% for Opus with tools; Qwen chose the harder-for-everyone setting and applied it consistently.

One small presentation note on AutomationBench-AA: Qwen4-Max's 72.5 is bold, and Kimi's 73.3 beside it is higher.

**HealthBench Professional matches Artificial Analysis.** No lab's card I read carries it, but AA's page data does: Opus 5.5 at 0.599, GPT-6.1 Sol at 0.651 and GPT-6 Astra at 0.660, which are Qwen's 59.9, 65.1 and 66.0. Kimi's 57.2 is not in AA's data, and this row is another one sourced from AA without a footnote saying so.

**JobBench, Chartography and Video-Index I could not check.** For JobBench Qwen says it re-ran everything on "the updated dataset and evaluation code", linking a specific commit (`660b33a`) of the JobBench repository, so no earlier table is comparable. Chartography is a no-tools setting; Anthropic and Moonshot publish only with-tools numbers (Opus 89.0 with tools against 66.3 here). Video-Index carries no source and I found none. CodeArena and AgentArena are cited from Arena, which refused my reader.

Counted over all 16 panels: 7 match a named source, 2 match Artificial Analysis without saying so, 1 differs from the card, and 6 I could not check. My overall reading: the comparator numbers on this chart are mostly copied faithfully from a named source. The real problems are two rows sourced from AA without a footnote and one row with unexplained values. That is better than most launch charts this year. Less visibly, the chart chooses its fights: no Google, no Fable, effort levels unstated per bar, and bold type on panels Qwen4-Max does not win.

## What a third party measured

The neutral number is [Artificial Analysis's Intelligence Index](https://artificialanalysis.ai/models/qwen4-max) v5.0.1, nine evaluations run by AA itself. Qwen4 Max scores 42.9 (the page rounds it to 43). For the same comparators: Opus 5.5 (max) 59, GPT-6 Astra (max) 57, GPT-6.1 Sol (max) 55, Kimi K3.1 Pro 46. Qwen4-Max is 38th of the 81 models AA ranks, above the median of 41 for its class and below every rival on Qwen's chart. AA's page does not show Qwen3.8-Max, so I cannot place the predecessor on the same scale.

The breakdown is more useful than the index, because it shows a shape rather than a rank:

| AA evaluation | Qwen4 Max | Kimi K3.1 Pro | Opus 5.5 (max) | GPT-6.1 Sol (max) |
|---|---|---|---|---|
| Terminal-Bench 4.0 | 48% | 67% | 60% | 56% |
| Terminal-Bench-Science 0.1 | 23% | 34% | 59% | 58% |
| FrontierCode-AA 2.0 | 26% | 25% | 46% | 41% |
| HLE-Diamond | 45% | 37% | 68% | 59% |
| AA-Omniscience accuracy | 44% | 49% | 66% | 62% |
| AA-Omniscience non-hallucination | **72%** | 63% | 50% | 48% |
| AutomationBench-AA | 73% | 73% | 70% | 65% |
| GDPval-AA v2.1 (Elo) | 1809 | 1861 | 1866 | 1607 |
| AA-Briefcase v1.1 (Elo) | 1686 | 1674 | 1801 | 1555 |

Read across the rows and Qwen4-Max is a knowledge-work and tool-workflow model that is weak at agentic coding. On AutomationBench-AA, GDPval-AA and AA-Briefcase it sits with the leaders. On the two terminal benchmarks and FrontierCode it is last or near last of these four. That matches Qwen's own emphasis: the blog leads with Work360, finance, law and healthcare, not coding.

The row I would underline is AA-Omniscience's non-hallucination rate. It measures how often a model declines rather than invents an answer it does not know. Qwen4 Max is at 72%, the best of the five, while its accuracy on the same evaluation is the lowest. A model that knows less but says so more often is a reasonable trade for the professional work the blog is selling. It is also the one strength nobody at Qwen mentioned.

AA also measures verbosity. Running the index, Qwen4 Max generated 127M output tokens, against a median of 78.6M for comparable models. Hold that number; it matters for the cost section.

<Figure
  src="https://media.thesatyajit.com/ai/articles/qwen4-max/fig6.jpg?v=c63d31658e8157be"
  alt="A dark radar chart titled WORK 360 comparing Qwen4-Max and Qwen3.8-Max across 26 industry domains around the circle, including Design, Coding, Data Analysis, Finance, Law, Consulting, Logistics, Healthcare, Education, Manufacturing and Energy. The Qwen4-Max polygon is larger in most directions. To the right, 'Industry benchmark': Qwen4-Max 52.69, Qwen3.8-Max 47.74."
  caption="Work360, Qwen's own benchmark: 26 domains, Qwen4-Max at 52.69 against 47.74. The radar's per-domain values sit in a script I could not download, so only the two totals are checked here. (Qwen, Qwen4-Max launch thread on X, third post's image, Figure 1.)"
/>

Work360 is Qwen's in-house benchmark, built from the taxonomy described earlier, and the 52.69 against 47.74 is a 10.4% relative gain. The tasks are not public, so it cannot be checked, and it is the benchmark the cost-per-task claim is built on. Keep both facts in mind for the next section.

## Fewer tokens, lower prices, and what "62%" is made of

The thread's first highlight: "Outperforms Qwen3.8-Max with up to ~50% fewer tokens, while average cost per task drops over 60% in our internal evaluation." The blog gives the detail.

<Figure
  src="https://media.thesatyajit.com/ai/articles/qwen4-max/fig3.png?v=9de87d0db90ee375"
  alt="Two scatter plots of score against tokens per task, each with three effort levels, Low, High and Xhigh, for Qwen4-Max (solid line) and Qwen3.8-Max-0902 (dashed). Work360: Qwen4-Max from about 91K tokens at score 46.6 (Low) to about 96K at 48 (High) to about 127K at 52.7 (Xhigh); Qwen3.8-Max from about 135K at 42.3 to about 148K at 43.5 to about 166K at 47.7. Terminal-Bench 4.0: Qwen4-Max from about 122K at 29.4 (Low) to about 128K at 31.5 (High) to about 151K at 48.5 (Xhigh); Qwen3.8-Max from about 202K at 19.3 to about 250K at 31.5 to about 289K at 38."
  caption="Score against tokens per task at three effort levels. At equal effort Qwen4-Max uses fewer tokens and scores higher on both benchmarks. Values in the alt text are read off the plot. (Qwen, Qwen4-Max blog, Figure 2.)"
/>

Reading the points off the plot, the blog's percentages check out. On Work360 at Xhigh, Qwen4-Max uses about 127K tokens per task against Qwen3.8-Max's 166K, a drop of about 24%; at High, about 96K against 148K, about 35%. On Terminal-Bench 4.0 at Xhigh, about 151K against 289K, about 48%; at High, about 128K against 250K, about 49%. The "up to ~50%" in the thread is the Terminal-Bench number, the best case.

Look at the Terminal-Bench panel once more, though. Qwen4-Max's High point scores 31.5 and Qwen3.8-Max's High point also scores about 31.5. At High effort the new model reaches the same score with half the tokens. That is a clean efficiency result. At Xhigh it reaches 48.5 against 38 with 48% fewer tokens, which is better and cheaper at once. On Work360 the gaps are smaller but in the same direction.

What does "tokens per task" count? The chart does not say, and the cost claim tells you. Qwen4-Max's output price is \$4.50 per million. If 127K tokens were everything a task consumed, input and output together, the task could cost at most 127K times \$4.50 per million, which is \$0.57. The blog says \$1.67. So the chart's tokens are output tokens (or at least exclude most input), and most of each task's cost is input: the agent re-reading its own growing context on every turn, largely from cache.

That lets me decompose the claim. A task costs

$$
\text{cost} = I\,\big(h\,P_\text{cache} + (1-h)\,P_\text{in}\big) + O\,P_\text{out}
$$

with $I$ input tokens, $h$ the share served from cache, $O$ output tokens. Qwen gives the cost and the chart gives $O$; pick a cache rate and solve for $I$. The blog does not say which effort level the cost claim used. I assume Xhigh, the effort its Work360 score is quoted at, so the output figures are the Xhigh points. At 90% cached, Qwen3.8-Max's \$4.43 needs about 8.1M input tokens per task and Qwen4-Max's \$1.67 about 5.1M. At 95% cached, about 10.2M and 7.5M. Agentic tasks on these benchmarks run to millions of input tokens, so those are plausible.

Now ask how much of the 62% is the price cut alone. Charge Qwen3.8-Max's implied tokens at Qwen4-Max's prices: at 90% cached the task falls from \$4.43 to about \$2.50, a 43% cut; at 95%, to about \$2.23, a 50% cut. The rest of the way to \$1.67 is the model using fewer tokens. So roughly two-thirds to four-fifths of the claimed saving is the new price list, and the remainder is the model. Both are real, but the price cut is a business decision that could be applied to the old model too, and the token cut is the engineering.

<TaskCost />

One more thing about the 62%. The [Chinese version of the blog](https://qwen.ai/blog?id=qwen4-max) gives the same comparison in yuan: "单个任务的平均费用从 26.58 元降至 11.16 元，降低了 58%" (average cost per task fell from 26.58 yuan to 11.16 yuan, down 58%). 11.16 over 26.58 is a 58.0% drop; 1.67 over 4.43 is 62.3%. The two posts describe one evaluation and disagree by four points. The likely reason is that the yuan and dollar price lists were cut by different proportions, which would make the "62%" partly a property of which region's prices you pay. Qwen does not explain it.

## Prices, against the models on the chart

| per 1M tokens | input | output | cached input | source |
|---|---|---|---|---|
| **Qwen4-Max** | \$1.50 | \$4.50 | \$0.075 | QwenCloud |
| Qwen3.8-Max | \$2.00 | \$6.00 | \$0.25 | QwenCloud |
| GPT-6.1 Sol | \$2.00 | \$10.00 | \$0.10 | Artificial Analysis |
| Kimi K3.1 Pro | \$2.00 | \$10.00 | \$0.20 | Artificial Analysis |
| Opus 5.5 | \$4.00 | \$20.00 | \$0.20 | Anthropic |
| GPT-6 Astra | \$10.00 | \$50.00 | \$1.00 | Artificial Analysis |

Against its predecessor, input and output are both down 25%, and implicit-cache input is down 70% (\$0.25 to \$0.075), exactly as the thread says. The explicit cache read fell from \$0.17 to \$0.075. Creating a five-minute explicit cache costs \$1.875 and a one-hour one \$3. The model page lists one price for the whole window. There is no surcharge tier above 256K or 128K, as some providers charge. Unlike Qwen3.8-Max's page, Qwen4-Max's lists no batch price yet.

On list price alone it is the cheapest model in that table on every line, and the cached-input price matters most, because agent tasks are mostly cached input. On the same token mix it costs less than half of Kimi K3.1 Pro or GPT-6.1 Sol.

But nobody runs the same token mix. Artificial Analysis's cost per task on its index, which multiplies each model's own measured token usage by its own prices, puts GPT-6.1 Sol (max) at \$1.27, Qwen4 Max at \$3.27, Kimi K3.1 Pro at \$3.68, GPT-6 Astra (max) at \$6.24 and Opus 5.5 (max) at \$10.04. Sol's list prices are higher than Qwen's and it is still about 2.6 times cheaper per task, because it uses far fewer tokens. AA's per-task cost split shows it: for Qwen4 Max, \$1.12 of cache reads at \$0.075 per million is about 14.9M cached tokens per task, plus \$0.47 of output, about 105K tokens. For Sol (max), \$0.25 of cache reads at \$0.10 is about 2.5M cached tokens, plus \$0.68 of output at \$10, about 68K. Qwen4-Max reads about six times as much context per task. That is my arithmetic on AA's numbers, and it is the clearest single reason the cheapest price list is not the cheapest bill.

The Token Plan is the other way to pay. It is a monthly credit subscription for coding and agent tools. The page lists two prices per tier, a launch price and a regular one: Lite is \$6 (regular \$8) for 20,000 credits a month, Pro \$43 (regular \$51) for 200,000. Credits are not tokens. The docs' example request costs about 3.18 credits for some 50K tokens on a cheaper model, and per-model credit rates are not published on the page I read, so I cannot convert a Qwen4-Max task into credits. The plan lists `qwen4-max` and a separate `qwen4-max-preview` at a limited-time 80% discount, and it is sold only in the Singapore region.

## The case studies, with the parts the videos show

The blog spends most of its length on case studies. They are demonstrations, not evaluations: one run each, chosen by Qwen, mostly with partner companies. They are still worth reading closely, because the videos sometimes say more than the text.

<Video
  src="https://ai.satyajit.si/articles/qwen4-max/clip1"
  poster="https://media.thesatyajit.com/ai/articles/qwen4-max/clip1-poster.jpg?v=7c7c01e75515c26a"
  alt="A screen recording of a web tool building grey 3D blockouts of a city block, followed by split frames: on the left a grey untextured blockout of a street and a skateboard, on the right a photorealistic shot of a chef skateboarding down an autumn New York street, framed the same way."
  caption="Blockout to film: Qwen4-Max builds the grey 3D scene and sets the camera; a video model, WonderClip, renders each shot to match it. The photoreal frames are generated video, labelled AI-generated in the original. (Video from @Alibaba_Qwen's post on X.)"
/>

The 3D video is the clearest about who does what. Qwen4-Max writes the script, builds parametric blockouts (grey geometry: streets, a staircase, a restaurant with tables), and animates cameras through them. A separate video-generation model, WonderClip, renders each blockout shot as photoreal footage. The blog says this directly: "Parametric blockouts ensure consistent geometry, scale, and spatial relationships". The language model is the director and set builder. The pictures you remember are another model's.

<Video
  src="https://ai.satyajit.si/articles/qwen4-max/clip2"
  poster="https://media.thesatyajit.com/ai/articles/qwen4-max/clip2-poster.jpg?v=4a3a12ce9d90b22c"
  alt="Animated slides comparing a conventional CAM programming workflow, with program revisions after trial machining, against a Qwen-assisted workflow that catches issues in simulation, ending on a table: analysis and operation planning 270 minutes to 11, strategy setup and toolpath generation 190 to 10, simulation checks 10 to 2, program output 5 to 1, total 475 minutes to 24 minutes, the 24 marked 'Pending Confirmation'."
  caption="The manufacturing claim's own table: 475 minutes of CAM programming to 24, with '(Pending Confirmation)' printed under the 24. (Video from @Alibaba_Qwen's post on X.)"
/>

The manufacturing case says "the manual effort required to program a single workpiece fell from approximately 475 minutes to 24 minutes, a reduction of about 95%." The table in the video adds up: 270 + 190 + 10 + 5 is 475, 11 + 10 + 2 + 1 is 24, and 24 over 475 is a 94.9% reduction. Under the 24, in small type, the video says "(Pending Confirmation)". The blog drops that qualifier. It is one workpiece, in one showcase, at partner companies SANF and Pacific Union, with the headline number not yet confirmed by the people who made it. The table also compares a whole conventional workflow against the time with Qwen, and a human engineer still reviews toolpaths in the second column.

<Video
  src="https://ai.satyajit.si/articles/qwen4-max/clip3"
  poster="https://media.thesatyajit.com/ai/articles/qwen4-max/clip3-poster.jpg?v=dd51e779cb4a2fdf"
  alt="Footage from an automated chemistry lab with an overlay reading 'Wet-Lab Validation', runtime counters near 19 hours and 12 candidates. A robot arm handles vials, a masked researcher in glasses looks on, a gloved hand holds a tube of yellowed liquid, a 'Qwen AI Glasses Recognition: Anomaly detected' tag appears, and a user message reads 'The sample changed color. Check the electronic lab notebook, figure out why, and update the coolant sc...'"
  caption="Hour 19 of the coolant run: a person holds up a discoloured sample and a user message asks the agent to check the lab notebook and update its screen. (Video from @Alibaba_Qwen's post on X.)"
/>

The coolant case is the most impressive and the one whose wording I would push on hardest. The blog says that during a 48-hour run "Qwen4 worked entirely on its own". The video's counters show the funnel: 2,699,653 candidate molecules, then 1,483,234 after structure screening, 4,744 after property prediction, 178 into retrosynthesis, 12 synthesised in the automated wet lab, and after four rounds of active learning, one new coolant molecule, synthesised and tested. That is a real closed loop and the robot does real chemistry.

At the 19-hour mark, though, a researcher holds up a vial that has changed colour and a message from "user" tells the agent: "The sample changed color. Check the electronic lab notebook, figure out why, and update the coolant sc[reening]". The next screen shows "New stability constraint added" feeding round two. That is a human noticing a failure and steering the search. It is good practice, and it is exactly what the blog's own Live Delivery section argues for. It is not "entirely on its own".

The other cases, briefly, with their numbers as the blog gives them:

- **Drug discovery** on DP Technology's PharmMaster, against the NLRP3 inflammasome: 454 tool calls, 3,239 computed metric evaluations, 24 candidate molecules, and a final candidate whose relative binding free-energy estimate puts its affinity at about 3.6 times the patent-derived reference. Computed, not measured in a wet lab; DP Technology's experts say it warrants wet-lab validation.
- **Legal due diligence**: 198 inconsistently named working papers sorted into 14 folders, and an 86-page report of over 60,000 Chinese characters covering 12 review areas and 14 legal issues.
- **Critical care**: one patient's six-day record, including 1,433 medical images, with subagents reading hundreds of CT slices; four management recommendations the blog says match the physician's orders that day.
- **Finance**: 90 MCP tools for market data, with Excel and PowerPoint deliverables whose charts link back to the workbook cells.
- **Cloud scheduling** at Alibaba Cloud: data-annotation call costs down 10.42% on average against a reference, GPU whole-machine idle duration up 4.62%, and CPU rescheduling solved more than 14.61 times faster.

None of these can be reproduced from outside. Each is one run by the vendor with a partner. I read them as a list of what Qwen pointed the model at in post-training, which matches the AA breakdown: document-heavy professional work, not terminal coding.

## What is open, and what is not

**Qwen4-Max: not open.** No weights, no report, no licence beyond QwenCloud's terms. This is a change. Qwen3.8-Max, the previous flagship, shipped open weights a week after launch under a custom licence ([our read of those files](/articles/qwen3-8-open-weights)). The Qwen4-Max thread makes no such promise; it promises "open weights of smaller Qwen4 models" instead, and the blog's summary says the smaller models are "coming to open source, built on the same lineage and trained with the same generation of techniques".

**The architecture: largely open already.** Qwen3.8-Flash-Next's weights, its report and the `qwen4_exp` model code in vLLM and SGLang are public, and they describe the same three components. What you cannot get is the flagship's widths, expert counts or training recipe.

**The harness plugin: open.** The blog announces the [Qwen-Live-Delivery-Plugin](https://github.com/QwenLM/Qwen-Live-Delivery-Plugin), Apache-2.0, the repository created two days before launch. It is a skill, an MCP server and lifecycle hooks that make a long-running agent ship a usable first version early, publish snapshots, and accept the user's feedback mid-task. Its README says "Available at launch: Codex CLI". The plugin Qwen open-sourced alongside its flagship runs first in OpenAI's coding agent, using whatever model Codex is configured with. That is either admirable neutrality or a sign of where Qwen thinks agent users already are. Probably both.

<RepoCard repo="QwenLM/Qwen-Live-Delivery-Plugin" />

**A hands-on run: not possible today.** There is no checkpoint of any Qwen4 size to run on a GPU. The API's model page showed "Quota temporarily unavailable" for the free tier when I read it, so I made no API calls; everything above about the model's behaviour is the vendor's or Artificial Analysis's. The only Qwen4-architecture model you can run is Flash-Next, and its smallest GGUF is 75 GB.

## Where I come down

The architecture is the real news, and it is not new today. Qwen took the design it previewed in Flash-Next (three linear-attention layers to one compressed sparse-attention layer, four gated residual lanes, a large n-gram lookup table) and showed it trains cleanly at 2.4T with 25% less compute per token than its own previous flagship. That is a meaningful result for anyone betting on hybrid linear attention at frontier scale. It would be a far more useful result with a report.

The benchmark chart is more honest than most. Most comparator bars trace back to a named public source, and where they do not, the row tends to use a stricter, more consistent source than the labs' own pages. The Terminal-Bench and HealthBench rows should say they are Artificial Analysis's. The ProgramBench row needs its scoring rule and sources. And the overall story the chart tells, "a step up from Qwen3.8-Max", is true. The story a reader might infer from all that blue bold type, that it competes with Opus 5.5 and GPT-6 Astra, is not supported by the third-party index, where it sits 14 to 16 points behind them and 3 behind Kimi K3.1 Pro.

The price is what I would actually act on. At \$1.50, \$4.50 and \$0.075 cached, it is the cheapest list price on the chart by a wide margin. For document-heavy agent work, where AA's breakdown says it holds its own and its non-hallucination rate is the best measured, it is worth trying at that price. For terminal and repository coding, AA's numbers say to keep using what you use now. And measure your own cost per task before you believe anyone's, including mine: Qwen4-Max is verbose enough that a model with twice its list price came out cheaper per task in the one neutral measurement available.

Last, a wish. Qwen3.8-Max shipped weights. Qwen4-Max ships a promise about smaller models. If those arrive with the Flash-Next level of documentation, this architecture will be the most thoroughly understood one at the top of the open-weight tables. If they do not, the flagship's design will be readable only in a diagram and a paragraph, which is where it is today.

<Callout type="note">
**How I checked.** Read: the English and Chinese blog posts (through the JSON API the page loads), the launch thread and its three videos (frames pulled with `ffmpeg`), the QwenCloud model pages for `qwen4-max` and `qwen3.8-max`, the Token Plan page and docs, Qwen3.8-Flash-Next's `config.json`, Moonshot's Kimi-K3.1-Pro README table, Anthropic's Opus 5.5 launch page, Artificial Analysis's Qwen4 Max page and the per-model data it embeds, and the ALE, Mercor APEX-Agents and Vals ProgramBench leaderboards, all on 16 November 2026. OpenAI's pages and Arena refused an automated reader, so GPT-only and Arena rows are unchecked. Computed: the layer-cost arithmetic from Flash-Next's shapes, the BPB percentages, the n-gram table sizes, the cost decomposition and the token figures derived from AA's cost split. Not run: the model. No weights exist, and I made no API calls.
</Callout>
