01 logo

Qwen4-Max Cut 58% of Its Own Bill. Here's Where the Savings Came From.

Alibaba's 2.4T flagship says less, caches more, and still makes you wait. A close read of the numbers behind the headline.

By JinPublished about 23 hours ago • 8 min read

The 2.4T Cost Ledger: Where Qwen4-Max Cut 58% of the Bill, and What It Left Out

Start with two numbers placed side by side.

In the Work360 evaluation, Qwen4-Max's average cost per task fell from ¥26.58 on Qwen3.8-Max to ¥11.16. In the same evaluation, on Terminal-Bench 4.0 at the Xhigh setting, average token usage per attempt dropped from 289K to 151K, while the score rose from 37.9 to 48.5. Put those two numbers together and a question appears: how much of the saving came from the model getting smarter, and how much came from it saying less? Those two sources produce very different user experiences. The first means you get better results at a lower cost. The second means the bill gets thinner, but the time you spend staring at the screen waiting for it to finish does not necessarily get shorter.

Architecture: Splitting the Fixed Cost of a 2.4T Model Across Four Cheaper Systems

Qwen4-Max still has a 2.4T total parameter base, but activated parameters per token drop from 95B on Qwen3.8-Max to 71B. If that 25% cut happened alone, the model would be prone to forgetting in long contexts. The compensation comes from three other layers, each with a concrete mechanism and number.

In every four layers, three are Gated DeltaNet, which compress historical information into a fixed-size state. The key phrase is "fixed size": the cost of maintaining memory over a million-token context goes from growing linearly with sequence length to being approximately constant. The remaining layer is Qwen Sparse Attention, which uses a lightweight indexer to select only the currently relevant context blocks at block granularity for attention computation. Not full-sequence dense attention, and not a simple sliding window: index first, then fetch blocks.

The 328B N-gram Embedding is an external memory layer. At the second layer, it introduces local token-pattern representations through table lookup. The computational overhead is negligible, but it moves part of knowledge storage from forward computation to retrieval. Gated Residual expands the residual stream into four parallel branches and uses dynamic gating to enhance cross-layer information transfer. The official claim is that pretraining at 2.4T scale showed no loss spikes throughout. For now that claim has only an official source, but the fact that Terminal-Bench scores rose rather than fell suggests training stability did not drag performance down.

Taken apart, this architecture does not make the model stronger in every dimension. It divides the work a 2.4T dense model would have to do among four cheaper systems: compressed state, sparse selection, table-lookup memory, and reduced activation. The 71B activation figure is the result, not the cause.

The Two Layers Behind the 58% Cost Reduction

The official 58% figure comes from Work360's average cost per task, from ¥26.58 to ¥11.16. That reduction is the sum of two independent sources; missing either one would not produce 58%.

The first layer is token efficiency. On Terminal-Bench 4.0 at Xhigh, usage drops from 289K to 151K, a reduction of almost 50%, while the score rises from 37.9 to 48.5. On Work360, token consumption at Xhigh and High falls by about 24% and 35%, respectively. These numbers do not mean the output got shorter. They mean that inside long agent loops, redundant tool-call round trips, repeated context restatement, and ineffective intermediate steps became less frequent. The model reached a completion level no lower than its predecessor with fewer actions.

The second layer is cache pricing. Cache-hit pricing falls to ¥0.5 per million tokens, one-twentieth of the normal input price of ¥10. The overseas cache-hit price drops by 70%. For agent tasks with dozens of tool calls that repeatedly read the same codebase or document, the first write of the source material is still billed at normal input rates, but every subsequent look back at it costs close to zero. The most expensive part of a long-horizon workflow happens to be cache hits.

Only when the two layers stack does the 58% appear. And they are not independent: higher token efficiency also reduces the frequency and total volume of cache writes. The same direction (say less, repeat less, recompute less) takes a cut out of both the token bill and the cache bill.

Independent Evaluations: It Wins the Agent Track, but It Is Not a Clean Sweep

On Agent Arena, Qwen4-Max debuts at No. 14 overall; Qwen3.8-Max was No. 39. Among Chinese models it ranks first, ahead of DeepSeek V4.1 Flash Max at No. 30. It ranks sixth globally in the Code Arena front-end development blind test, first in DeepSWE code repair, and scores 46.7 on Agents' Last Exam, an 18.8-point gain over the previous generation. On the track Qwen4-Max explicitly targets, completion of complex agent tasks, independent data supports the official capability narrative.

But another set of numbers needs to be placed next to those. Artificial Analysis Intelligence Index gives Qwen4-Max a score of 43, above the same-price median of 41, with an estimated cost per task of $3.27. The same analysis notes that Qwen4-Max generated 127M tokens during evaluation, very verbose relative to the 78.6M median. Its token-efficiency advantage is concentrated in agent and coding tasks; in open-ended Q&A or analytical scenarios, verbosity can return.

Plotly's data-analysis-specific test is more concrete: 35 of 43 questions passed, 81%, at a single-run cost of $2.29, with a median of 40 seconds per question. But Alibaba's own open-source Qwen 3.8 27B passes 38 of 43 on the same test at a cost of $1.71. The 27B weights fit on a 24GB GPU; the 2.4T Qwen4-Max is API-only. On data-analysis tasks that are single-turn or multi-turn but not ultra-long-horizon, the 2.4T flagship does not establish overwhelming superiority over a mid-sized model. Its value zone is more clearly anchored in long-horizon agent work that requires sustained progress across files, tools, and steps.

The Crack in the Experience: The Bill Shrank, but the Waiting Did Not Necessarily Shorten

The most concentrated feedback from the preview phase concerns thinking latency. Multiple testers reported that at the default xhigh setting, visible output speed was about 33 tokens/s. One concrete case: in Qoder, asking the model to generate a webpage of "a pelican riding a bicycle" took more than two thousand seconds without completion. At 33 tokens/s, in the time it takes to brew a drip coffee bag, it outputs less than two thousand words. The official explanation points to scheduling strategy and compute quota allocation during the preview phase. Whether latency improves materially in the official release still lacks systematic independent speed-test data.

Token efficiency measures consumption on the bill; latency measures the duration for which your attention is occupied. For batch, asynchronous, parallelizable agent workflows, the former dominates cost. For interactive coding or real-time collaboration, the latter directly determines usability. Qwen4-Max's efficiency optimization leans toward the former.

Front-end UI visual presentation is another frequently mentioned weakness. Code Arena front-end programming ranks high, but some developers still find that it does front-end UI only so-so, with back-end and Work scenarios being its comfort zone. There is a gap between benchmark front-end scores and human subjective judgment of interface aesthetics and interaction detail.

On long-horizon stability, a preview-phase user reported that the model autonomously executed 229 consecutive turns over more than 90 minutes without interruption, stopping only when the test quota ran out. That validates the practical effect of Gated Residual and the training-stability design. Running for a long time and maintaining architectural decision consistency after running for a long time are two different things; the latter requires longer production-grade use to verify.

Versus DeepSeek V4.1 Flash: Two Kinds of Saving

Place the concrete parameters side by side and the divergence is clear.

DeepSeek V4.1 Flash: 552B total parameters, 8B activated in prefill, 16B activated in decode, 196B Engram conditional memory, $0.30 per million input tokens, $1.20 per million output tokens. Its efficiency comes from asymmetric activation paths and extreme KV-cache compression: a Causal Encoder-Decoder architecture sends input processing and output generation down different compute paths, Compressed Sparse Attention 2 shares KV and indices across layers, and FP4 KV cache holds global cache under a million-token context to 890 bytes/token. The goal is to use a medium-sized base to push the unit cost of repeatable, input-heavy workloads close to its limit.

Qwen4-Max: 2.4T total parameters, 71B activated, 328B N-gram Embedding, ¥10 per million input tokens, ¥30 output, ¥0.5 cache hit. Its efficiency comes from fine-grained energy management inside a flagship-scale model: GDN compresses historical state, QSA sparsely selects context, N-gram lookup shares memory load, and reduced activation lowers the fixed cost of each forward pass. The goal is not to be the cheapest model, but to keep cost in a mid-price range in scenarios that need flagship-level knowledge coverage and complex agent capability.

On independent metrics, Qwen4-Max scores 43 on the Intelligence Index with an estimated cost per task of about $3.27; DeepSeek V4.1 Flash scores 33 at a cost on the order of $0.60. Qwen4-Max uses a higher unit cost and stronger comprehensive agent capability to buy upward coverage of task complexity; DeepSeek Flash uses lower absolute capability and extreme unit cost to buy downward efficiency in scale replication. One evaluation claims Qwen4 achieved better web-development results than DeepSeek V4.1 Flash at about half the token usage, but that is an efficiency advantage in a specific task type, not a comprehensive cost lead.

That 27B Number

Qwen4-Max's ledger is now open: 2.4T base, 71B activated, 58% lower cost per task, ¥0.5 cache price. It shows that a flagship model can, through architecture-level efficiency engineering, cut the average cost of long-horizon agent tasks to roughly 40% of the previous generation while maintaining and improving completion in agent and coding scenarios. The cache price of ¥0.5 per million tokens makes repeatedly reading the same source material economically sustainable on a flagship model for the first time.

But it is not the optimal solution for every scenario. It trails its own 27B in the data-analysis specialty, the Intelligence Index shows token redundancy remains high in non-agent scenarios, and the preview-phase latency perception has not been fully dissolved by official-release data. Qwen4-Max's efficiency advantage is scenario-dependent. It rewards users who organize tasks into a long-horizon shape that supports multi-step work and caching.

Officially, mid- and small-sized models in the Qwen4 series will be open-sourced successively. In the Plotly test, Qwen 3.8 27B passes 38/43 in data analysis at $1.71, both better than the 2.4T flagship's 35/43 and $2.29. The next number that matters is when GDN's state compression, QSA's block-level sparsity, and N-gram's cheap capacity expansion descend into a 27B open-source weight. If that version can hold the 38/43 pass count while pushing cost down another notch, the local-deployment ledger will be more worth calculating than the API ledger.

That is where the 2.4T flagship stands. What comes next is how small a size the same architectural logic can still work at.


tech newsfact or fictionthought leadersapps

About the Creator

Jin

Writer of reamstories

https://reamstories.com/jin

Enjoyed the story? Support the Creator.

Subscribe for free to receive all their stories in your feed. You could also become a paid subscriber, letting them know you appreciate their work.

Subscribe For Free

Reader insights

Comments

There are no comments for this story

Be the first to respond and start the conversation.

Sign in to comment
    Written by Jin