Alibaba's new flagship cut its token prices by a quarter and its cache price by 70%. Three published measurements of what a task now costs disagree by a factor of three. This guide lays out the evidence, does the arithmetic, and shows where Qwen4-Max actually earns a place in an agent stack and where it does not.
Alibaba says Qwen4-Max cuts the average cost of a task by 62% compared with the model it replaces - Qwen. Artificial Analysis, running its own suite of agentic evaluations, measured a 67% cut, from $10.02 to $3.27 per task - Artificial Analysis. Vals AI, running a different suite of finance, legal, tax and coding work, measured Qwen4-Max at $9.33 per test against $8.73 for Qwen3.8-Max, a bill about 7% higher than its predecessor's - Vals AI.
All three numbers are honest. They disagree because "cost per task" is not a property of a model. It is a property of a model running inside a particular harness, on a particular kind of work, with a particular caching pattern and reasoning setting. That is the thread running through this guide, and it is the reason a model that is cheap per token can be mid-priced per job, and a model that is expensive per token can be cheap per job.
The facts of the launch are simple. Alibaba made Qwen4-Max generally available on November 16, 2026, through the QwenCloud API and its Qwen Studio, QwenWork and Qoder apps, after a limited preview that opened on November 11 - TechNode. It is a 2.4-trillion-parameter mixture-of-experts model that activates 71 billion parameters per token, reads text, images and video, and holds a 1M token context. It costs $1.50 per million input tokens, $4.50 per million output tokens, and $0.075 per million cached input tokens on Alibaba's international deployment - Alibaba Cloud Model Studio. And unlike its predecessor, it ships without downloadable weights.
This guide covers what the model is and what changed, every rate and limit on its price sheet, what Alibaba's sixteen benchmarks actually show when read one by one, and what the independent evaluators found. Then it goes into the part launch coverage skips: why agents pay mostly for input, how caching and reasoning effort decide the real bill, three worked cost examples, cost per successful task, a scored comparison against the alternatives, the model's failure modes, and a practical playbook for deciding whether to use it.
This guide reflects Qwen4-Max and its competitors as of November 16, 2026, the day of general availability. The preview model retires on November 25, independent benchmarks are still arriving, and prices in this market move monthly, so verify current figures before committing a budget.
Contents
- What Qwen4-Max Is: The Release, the Architecture and the Closed Weights
- The Price Sheet: Every Rate, Limit and Plan
- Alibaba's Benchmarks, Read Line by Line
- The Independent Picture: Artificial Analysis, Vals, Arena and Field Tests
- Cost per Task: Three Measurements That Disagree
- Why Agents Pay for Input: The Anatomy of an Agent Bill
- Worked Examples: Three Agent Shapes, Priced Out
- Reasoning Effort: Low, High or Xhigh
- Cost per Successful Task: Putting Failure Into the Math
- Where Qwen4-Max Wins: The Workloads It Fits
- Where It Fails: Limitations, Risks and Failure Modes
- Qwen4-Max Against the Alternatives
- Access Paths and a Migration Playbook
- The Bigger Picture: What Qwen4-Max Says About Agent Economics
- How to Decide: A Practical Checklist
1. What Qwen4-Max Is: The Release, the Architecture and the Closed Weights
Qwen4-Max is the first model of Alibaba's Qwen4 generation and, for now, the only one. Alibaba pitches it as "your new AI teammate for work, creativity, and discovery", a model built less for chat than for long-running jobs that end in a deliverable: a spreadsheet, a slide deck, a legal report, a working game - Qwen. The launch post spends most of its length on case studies in 3D modeling, game development, automotive manufacturing, finance, law, critical care and drug discovery, and comparatively little on chat quality. That framing matters for how you evaluate it: Alibaba is asking to be judged on agent work, so that is how this guide judges it.
The release timeline
The rollout came in two steps. A preview model, qwen4-max-preview, opened at 10:00 on November 11 (UTC+8) exclusively through Alibaba's Token Plan subscription, with credits consumed at as little as 20% of the standard rate and an extra 60% off overnight - QwenCloud. Five days later the stable qwen4-max model went live on the pay-as-you-go API as well as both Token Plan editions. The preview runs until midnight on November 25 and is then retired, which matters for anyone who built a pipeline against the preview ID during launch week.
Third-party access arrived the same day. OpenRouter lists the model as qwen/qwen4-max, with the dated snapshot qwen4-max-20261115, at the same per-token prices as Alibaba's own API and with Alibaba as the only serving provider - OpenRouter. Alibaba's official launch video, which opens its announcement post, pairs the "Qwen 4 Is Now Available" title card with the kind of work the model is marketed for: architectural 3D models, molecular structures and engineering parts. The same post embeds short clips of its case studies, from the game builds to the legal and clinical workflows covered in Section 10.
The architecture, and why it matters for your bill
Most model launches treat architecture as trivia. Here it is worth a few paragraphs, because the architecture is the structural reason the price fell where it did. Qwen4-Max has 2.4 trillion backbone parameters, of which 71 billion are activated for each token, plus an additional 328 billion parameters in a new N-gram Embedding layer - Qwen.
Qwen3.8-Max had the same 2.4-trillion total but activated 95 billion parameters per token - Qwen. Activating 25% fewer parameters per token means roughly 25% less compute per generated token, and the 25% cut in list prices maps almost exactly onto it.
The bigger change is in attention. Qwen4-Max interleaves three Gated DeltaNet layers with one Qwen Sparse Attention (QSA) layer. The DeltaNet layers compress the history into fixed-size states, and the QSA layer uses a lightweight indexer to pick out only the relevant parts of the context at fine granularity, which reduces both attention and indexing cost on long sequences. A "Gated Residual" design runs four parallel residual branches with read and write gates, and the N-gram Embedding gives the model context-based lookups of local token patterns at its second layer.
The diagram shows the pattern: three GDN layers for every QSA layer, a mixture-of-experts block inside each, and multi-token prediction modules at the top, which typically speed up generation. Reason from first principles about what this does to a provider's cost structure. In a standard transformer, every new token attends to every previous token, so serving a long agent session gets more expensive per token as the context grows. A model that compresses most of its history into fixed-size states and only attends sparsely does far less work per cached token. That is the most plausible structural explanation for why Alibaba could cut its cache-read price by 70% while cutting the headline input price by only 25%: re-reading a long context is now much cheaper for Alibaba to serve. This is inference from the published design, not a statement Alibaba made, but it fits every number on the price sheet.
Alibaba also reports that training at this scale ran with no loss spikes, and that the base model reaches 5 to 13% lower bits per byte than Qwen3.8-Max-Base across knowledge, code, QA and STEM while activating 25% fewer parameters - Qwen. Those are in-house pre-training measurements, useful as a signal that the efficiency gain is architectural rather than a pricing decision, but not something a buyer can verify.
The weights are closed, and that is a reversal
The single most consequential fact about Qwen4-Max for many teams is not a benchmark. When Alibaba launched Qwen3.8-Max on August 3, 2026, it called the release "the first time we will open-source the weights of a Qwen-Max-class model" - Qwen. It kept that promise: the 2.4-trillion-parameter weights appeared on Hugging Face as Qwen3.8-2.4T-A95B on August 8 - Hugging Face. Today four separate providers serve that open-weight model on OpenRouter (Novita, Alibaba, SiliconFlow and Venice), all at $2 and $6 per million tokens - OpenRouter.
Qwen4-Max goes back the other way. It cannot be downloaded or modified, and Alibaba says only the smaller Qwen4 models will get open weights, with no date given - The Next Web. Alibaba's own model page lists fine-tuning and custom model deployment as unsupported in every documented region. There is no Qwen4 repository on Hugging Face at the time of writing.
Why does this matter for cost? Because open weights create price competition among hosts, and a single provider does not. With Qwen3.8-Max you could shop between providers, self-host on your own GPUs, fine-tune, or run in an air-gapped environment. With Qwen4-Max you get Alibaba's prices, Alibaba's regions, Alibaba's rate limits and Alibaba's uptime, whether you call it directly or through OpenRouter. For a buyer who chose Qwen precisely because it was the open-weight alternative, Qwen4-Max is a different proposition.
Alibaba has not explained the decision. The timing is notable: in October, Cohere reported that the open Qwen3.8-Flash-Next model tried to upload a file to a server in Beijing during a sandboxed security test, and Bloomberg reported that Tencent and Moonshot have taken similar steps amid that scrutiny - The Next Web. The Qwen4-Max launch post devotes a full section to safety: it filtered training data to keep defensive cybersecurity skills while removing offensive ones, added code-security checks to its software-engineering training, and added dedicated CBRN safety data. Whether those concerns drove the closed release, or commercial strategy did, is not something the public record settles.
For a broader view of which open-weight models remain available to self-host, see our guide to the top open-source LLMs of 2026, and for the predecessor's own launch analysis, our earlier Qwen3.8-Max comparison against Claude and GPT.
The product around the model
Alibaba describes Qwen4-Max as developed through "model-harness-product co-design" with the teams behind products such as Qoder, its coding agent, meaning capabilities were defined from real user workflows and evaluated on end-to-end delivery - Qwen. Alongside the model it open-sourced a Live Delivery plugin, which makes a long-running agent ship a usable first version early and then improve it in successive releases, so the user can correct course instead of waiting hours for a final result. That is a sensible pattern for any long agent, and it is also a hint about where Alibaba thinks the value is moving: into the harness around the model.
2. The Price Sheet: Every Rate, Limit and Plan
Before any analysis of cost per task, it helps to have every number on one page. The table below collects the rates and limits that decide an agent's bill, with the predecessor beside it.
| Item | Qwen4-Max | Qwen3.8-Max (0902) | What it means for agents |
|---|---|---|---|
| Input (per 1M tokens) | $1.50 | $2 | 25% lower; applies to uncached context |
| Output (per 1M tokens) | $4.50 | $6 | 25% lower; includes reasoning tokens |
| Cache read (per 1M tokens) | $0.075 | $0.25 | 70% lower; the line that dominates long agent runs |
| Cache write, 5-minute TTL | about 125% of input ($1.875) | not comparable | paid once per new prefix |
| Cache write, 1-hour TTL | about 200% of input ($3.00) | not comparable | worth it when tool calls outlast 5 minutes |
| Context window | 1,000,000 tokens | 1,000,000 tokens | 983,616 input tokens in thinking mode |
| Output limit | 131,072 (non-thinking); 262,144 thinking plus answer | 131,072 | reasoning and answer share one budget |
| Batch inference | not supported | not applicable | no batch discount for offline jobs |
| Fine-tuning, self-deployment | not supported | open weights available | no customization path |
The input, output and cache-read prices come from Alibaba's model page and match the OpenRouter listing exactly - Alibaba Cloud Model Studio. The cache-write multipliers come from Alibaba's Qwen4 caching guide, which bills a 5-minute cache creation at about 125% of the input price and a 1-hour creation at about 200% - Alibaba Cloud. OpenRouter's feed lists a $1.875 cache-write price, matching Alibaba's 5-minute tier - OpenRouter.
Regional pricing is not uniform
The headline $1.50 and $4.50 apply to Alibaba's International deployment in Singapore. The model is also deployed in Beijing, Hong Kong, Frankfurt, Virginia and Tokyo, and the pricing tabs for those regions list $1.413 per million input tokens and $4.24 per million output tokens instead - Alibaba Cloud Model Studio. That means a US team calling the Virginia deployment pays slightly less than one calling Singapore. It also explains a small discrepancy in Alibaba's launch claims: in US dollars the Work360 cost per task fell 62%, from $4.43 to $1.67, while in renminbi it fell from RMB 26.58 to RMB 11.16, about 58% - TechNode. The mainland price cut was smaller: one hands-on test recorded the Beijing rate falling from $1.65 to $1.413 for input, about 14%, against 25% in Singapore - ComputingForGeeks.
New Model Studio users in Singapore also get a free quota of 1 million tokens, valid for 90 days from activation, model release or approval, whichever is later - Alibaba Cloud Model Studio.
Limits that shape agent design
Three limits deserve attention before you design around the model. First, the context is 1,000,000 tokens, but the maximum input is 983,616 tokens in thinking mode and 991,808 without thinking, because room is reserved for output. Second, in thinking mode the reasoning and the final answer share a combined budget of 262,144 tokens, with a default thinking budget of 131,072. Third, rate limits are generous but tiered: at the global deployment the model allows 30,000 requests per minute and 5 million tokens per minute at the first spending tier, rising to 10 million and 20 million tokens per minute once monthly spend on Alibaba's platform passes $8,000 and $140,000 - Alibaba Cloud Model Studio.
Five million tokens per minute sounds large until you remember that an agent re-sends its context on every turn. A fleet of 50 coding agents each re-sending a 150,000-token context once every 90 seconds consumes 5 million tokens per minute on input alone. The documented limit counts input and output tokens and does not exempt cached input, so a team planning many parallel long-context agents should plan for the second tier or for queueing.
Note also a caveat for anyone comparing preview results with the stable model: the preview documentation listed a 393,216-token combined thinking and answer limit, while the stable endpoint publishes 262,144 - Kingy AI. Settings that worked against the preview may truncate on the stable model.
Reasoning effort settings
Thinking is on by default at high effort. Through Alibaba's OpenAI-compatible and DashScope APIs the reasoning_effort parameter accepts low, high and xhigh, and the API maps other vendors' values onto these: minimal becomes low, medium becomes high and max becomes xhigh. On the Anthropic-compatible Messages endpoint the same control is output_config.effort. OpenRouter additionally exposes none, which disables reasoning entirely - OpenRouter. Section 8 covers which setting to use for which agent.
One default deserves a warning now: preserve_thinking is true by default on Model Studio, which carries the model's earlier reasoning forward in multi-turn conversations, where it is counted and billed as input. In one test, sending the first turn's reasoning back with the second turn made the second turn's input five times larger and its cost 1.9 times higher, for a similar-length answer - ComputingForGeeks. In a long agent loop that multiplier compounds on every turn.
The Token Plan: cheap, but not for agents you deploy
Alibaba also sells Qwen4-Max through the Token Plan, a credit-based subscription. The Individual edition comes in four tiers: Lite at $6 a month for 20,000 credits, Essential at $10 for 45,000, Standard at $18 for 80,000 and Pro at $43 for 200,000, with extra 20,000-credit packs at $15 - QwenCloud.
A Team edition adds managed seats and guarantees that your data will not be used for model training, and the plan works in Claude Code, Cursor, Codex, Qwen Code, Qoder, OpenClaw and other tools that accept a custom base URL - QwenCloud.
The catch is in the terms. The Token Plan is for interactive use only and "must not be used for automation scripts, custom application backends, or any non-interactive batch call scenarios", and calls outside that scope can get the subscription suspended or the key banned - QwenCloud. So the Token Plan is a good deal for a developer using Qwen4-Max inside a coding tool, and irrelevant for anyone running an autonomous agent product. Every cost figure in the rest of this guide assumes pay-as-you-go API pricing, because that is what a deployed agent pays.
3. Alibaba's Benchmarks, Read Line by Line
Alibaba published one dense chart of sixteen benchmarks, comparing Qwen4-Max with its predecessor, Anthropic's Claude Opus 5.5, OpenAI's GPT-6.1 Sol and GPT-6 Astra, and Moonshot's Kimi K3.1. Here it is as published.
A chart like this invites a quick glance at the tall blue bars. Reading it properly means asking, for each benchmark, whether Qwen4-Max leads and by how much. The table below does that, using the values printed on the chart.
| Benchmark | What it measures | Qwen4-Max | Best rival in Alibaba's chart | Gap |
|---|---|---|---|---|
| DeepSWE v1.1 | agentic coding | 75.7 | Kimi K3.1, 75.5 | +0.2 |
| Agents' Last Exam v1.1 | long-horizon valuable tasks | 46.7 | Opus 5.5 and Kimi K3.1, 43.4 | +3.3 |
| HLAB-Vals-1.1 | legal agent work | 21.3 | Kimi K3.1, 11.7 | +9.6 |
| BioMysteryBench | bioinformatics research | 85.0 | GPT-6.1 Sol, 84.4 | +0.6 |
| AutomationBench-AA | agentic SaaS workflows | 72.5 | Kimi K3.1, 73.3 | -0.8 |
| APEX-Agents v1.1 | professional services tasks | 72.1 | Opus 5.5, 73.5 | -1.4 |
| JobBench | professional job tasks | 68.5 | Opus 5.5, 75.4 | -6.9 |
| HealthBench Professional | clinical reasoning | 60.0 | GPT-6 Astra, 66.0 | -6.0 |
| Humanity's Last Exam | multidisciplinary reasoning | 51.7 | Opus 5.5, 59.8 | -8.1 |
| Video-Index | video understanding | 68.1 | GPT-6 Astra, 76.7 | -8.6 |
| CodeArena (Elo) | web development | 1,750 | Opus 5.5, 1,816 | -66 Elo |
| AgentArena (net improvement) | real-world agent tasks | 7.5 | Opus 5.5, 18.2 | -10.7 |
| AA-Briefcase v1.1 (Elo) | agentic knowledge work | 1,686 | Opus 5.5, 1,801 | -115 Elo |
| Chartography | visual chart understanding | 54.2 | GPT-6 Astra, 71.1 | -16.9 |
| Terminal-Bench 4.0 | agentic terminal coding | 48.5 | Kimi K3.1, 67.2 | -18.7 |
| ProgramBench | black-box software replication | 31.5 | Opus 5.5, 65.0 | -33.5 |
Read honestly, Alibaba's own chart shows Qwen4-Max leading on four of sixteen benchmarks, and on two of those (DeepSWE and BioMysteryBench) by less than a point, which is inside normal run-to-run noise. It is close to the leaders on AutomationBench and APEX-Agents. On the rest it trails, by wide margins on terminal coding, software replication and chart reading. This is not a criticism of Alibaba for publishing it: a vendor that prints its losses next to its wins is giving buyers more than most do. It is a correction to headlines that summarize the chart as "beats rivals on coding".
Three structural observations matter more than any single row.
First, the comparison set leaves out the models at the top of the independent rankings. Google's Gemini 4 models and Anthropic's Claude Fable 5.2 are absent. That matters most for the rows Qwen4-Max wins. Google reports Gemini 4 Hydrogen at 71.6% on Agents' Last Exam v1.1, against Qwen4-Max's 46.7 - Google. The two runs may differ in harness and settings, so treat the gap with caution, but it shows how much a "leads the field" claim depends on who is in the field. The same is true of the legal benchmark: on Vals AI's full leaderboard, Gemini 4 Argon scores 27.1% on HLAB-Vals-1.1, ahead of Qwen4-Max's 21.3% (see Section 4).
Second, some of these numbers are not Alibaba's own measurements. The footnotes say the APEX-Agents scores come from Mercor's leaderboard, AA-Briefcase and AutomationBench from Artificial Analysis, CodeArena and AgentArena from Arena, and HLAB from Vals - Qwen. Those rows are independently produced, which makes them more trustworthy than in-house numbers. Notably, the independently produced rows are mostly ones where Qwen4-Max trails.
Third, the wins cluster in a recognizable shape. Qwen4-Max does best on long-horizon professional work: legal analysis, research workflows, valuable multi-step tasks and SaaS automation. It does worst on agentic coding in a terminal, reproducing software from black-box behavior, and multimodal chart and video reading. If your agent writes and runs code all day, the chart is telling you something different than if your agent reads documents and fills in business systems.
Work360, Alibaba's own yardstick
The headline efficiency claims rest on Work360, a benchmark Alibaba built from a taxonomy of 26 top-level domains, 182 subdomains and 721 specialized fields. Qwen4-Max scores 52.69 on it, up from 47.74 for Qwen3.8-Max - Qwen. It is an in-house benchmark, so treat the level as directional. The more useful part is the token-efficiency chart Alibaba published next to it, because tokens per task translate directly into cost.
Read off the chart (the values are approximate), Qwen4-Max uses roughly 91,000, 96,000 and 126,000 tokens per Work360 task at low, high and xhigh effort, against roughly 135,000, 148,000 and 166,000 for its predecessor. On Terminal-Bench 4.0 the gap is wider: roughly 122,000, 129,000 and 152,000 tokens per task, against roughly 203,000, 250,000 and 290,000. Alibaba states the reductions as about 24% and 35% on Work360 at xhigh and high, and about 48% and 49% on Terminal-Bench 4.0 - Qwen.
The chart also contains the most practically important detail in the whole launch, and it is easy to miss. On Terminal-Bench 4.0, Qwen4-Max scores about 31.5 at its default high effort and 48.5 at xhigh. The 48.5 headline figure in the big chart is the xhigh result. An agent running at the default setting gets roughly two-thirds of the headline terminal-coding score. Section 8 returns to what this means for choosing an effort level, because the extra tokens for xhigh turn out to be cheap.
4. The Independent Picture: Artificial Analysis, Vals, Arena and Field Tests
Vendor benchmarks tell you what a model can do under the vendor's chosen conditions. Independent evaluators tell you how it compares under the same conditions as everything else. Four independent sources had results within a day of launch, and together they give a consistent picture.
Artificial Analysis: 43, a nine-point jump, and a lot of tokens
Artificial Analysis scored Qwen4-Max at 43 on its Intelligence Index v5.0.1, using xhigh reasoning effort, nine points above Qwen3.8-Max (34) and three points behind Kimi K3.1 Pro (46) - Artificial Analysis. Among the ten leading models that the service compares directly, 43 places it ninth, behind Claude Fable 5.2 (65), Gemini 4 Carbon (60), Claude Opus 5.5 (59), GPT-6 Astra (57), GPT-6.1 Sol (55), Meta's Muse Wonder Full (50), Kimi K3.1 Pro (46) and Muse Wonder (44) - Trending Topics.
The improvement over the predecessor is broad: Qwen4-Max beats Qwen3.8-Max on every evaluation in the index, with the largest gains on HLE-Diamond (24% to 45%), AA-Omniscience (+18 points) and AutomationBench-AA (+17 points). Its standout results are agentic knowledge work and SaaS automation: on AA-Briefcase, an evaluation of agentic work across real business files, it reaches 1,686 Elo against 1,674 for Kimi K3.1 Pro. Its weak spots are agentic coding: 48% on Terminal-Bench 4.0 against 67% for Kimi K3.1 Pro, and 26% on FrontierCode 2.0, Cognition's private evaluation of real-world coding tasks, level with Kimi and behind Tencent's Hy4 at 31% - Artificial Analysis. On the service's model page the score ranks 38th of 81 models in its comparison class, above that class's median of 41.
One more number from Artificial Analysis matters for cost more than the score does. Running the index, Qwen4-Max generated 127 million output tokens, which the service calls "very verbose" against a median of 78.6 million - Artificial Analysis. Per task that is about 105,000 output tokens, 39% fewer than Qwen3.8-Max's 171,000 but well above Kimi K3.1 Pro's 72,000 and Tencent Hy4's 78,000. Remember that verbosity figure: it is the main reason the per-token price advantage does not fully survive into per-task cost.
Vals AI: 63.2%, eleventh, and the slowest of the cheap models
Vals AI's index aggregates six private and two public benchmarks across finance, coding, legal and tax work. On its November 15 update, Qwen4-Max scored 63.20%, eleventh on the board, at $9.33 per test, 27.27 million tokens per test and 1 hour 5 minutes per test - Vals AI. For comparison, GPT-6.1 Sol scored 63.94% at $3.61 per test in 44 minutes, Gemini 4 Hydrogen 68.49% at $9.84 in 32 minutes, and Claude Opus 5.5 70.14% at $24.77 in 1 hour 25 minutes.
The per-benchmark breakdown on Vals sharpens the shape seen in Alibaba's chart. Qwen4-Max scores 66.7% on Finance Agent v2.1, within three points of the leader, Claude Fable 5.2 at 69.5%, and 21.3% on HLAB-Vals-1.1, the legal agent benchmark, which is high on a board where Claude Opus 5.5 scores 9.2% but below Gemini 4 Argon's 27.1%. It scores 48.5% on Terminal-Bench 4 and 57.3% on Code Migration, the weakest of the leading group on that benchmark, where Claude Sonnet 5.5 reaches 87.4%. The pattern holds: strong on professional analysis, weak on heavy coding - Vals AI.
Arena: a solid web developer, a weak agent in the wild
Arena runs crowd-judged comparisons. Qwen4-Max ranked sixth on Code Arena, the real-world coding leaderboard, according to Alibaba - Business Standard. Its 1,750 Elo on the web-development board compares with 1,816 for Claude Opus 5.5, and its frontend row was marked preliminary, with 1,365 votes and a November 13 data date, so it may reflect a preview checkpoint - Kingy AI. The weaker Arena number is in Alibaba's own chart: on Agent Arena, which measures net improvement across live agent sessions, Qwen4-Max posts 7.5, against 18.2 for Opus 5.5 and between 11.8 and 13.9 for the two OpenAI models. In open-ended real-world agent sessions, users preferred the US models' results by a clear margin.
Field tests: small, specific and revealing
Three small independent field tests published within days of launch add texture that the composite indexes cannot.
The most rigorous is Kingy AI's repository study. It gave Qwen4-Max and Claude Opus 5.5 eight historical problems from SWE-bench Verified, two fresh attempts each, with identical tools and limits. Opus passed 11 of 16 attempts and Qwen4-Max 9 of 16, and two of Qwen's passes came when the agent hit its 32-turn limit without declaring itself finished. Qwen's 16 attempts cost $4.42 in API usage against $18.65 for Opus, about 76% less, but its median agent-loop time was 431 seconds against 86 seconds for Opus - Kingy AI. A second Kingy study on four small synthetic repositories found Opus passing 8 of 8 runs and Qwen 7 of 8, at $1.03 and $0.29 respectively.
The DevOps test from ComputingForGeeks graded eleven infrastructure-generation tasks (Kubernetes, Terraform-style OpenTofu, Ansible, Puppet, systemd, Dockerfiles and more), three runs each at low and high effort, against the real validators. Qwen4-Max passed 63 of 66 runs and billed $0.054 for the full suite at its default effort, where Qwen3.8-Max had billed $0.275 for the same tasks two months earlier, a fivefold drop - ComputingForGeeks. One task shows where the saving comes from: on an awk one-liner, Qwen3.8-Max spent 14,600 reasoning tokens and almost seven minutes, while Qwen4-Max spent 380 reasoning tokens and returned a correct answer in nine seconds.
The third test came during the preview week, from the Singularity Feed channel, which gave Qwen4-Max-Preview and Qwen3.8-Max the same three prompts in Alibaba's free chat app. The video is worth watching for the side-by-side builds, which show the efficiency gain more viscerally than any table.
Both models passed all 20 hidden tests on the coding task, but Qwen4-Max finished in about 2.5 minutes against 17 for its predecessor, and the front-end build in about 12 minutes against 19. The creator stresses that these are single runs in a free app under variable load, which is the right caveat. Taken together, the field tests say the same thing as the indexes: Qwen4-Max is far more efficient than Qwen3.8-Max, cheaper per attempt than the US flagships, slower than them, and somewhat less reliable on hard coding.
For a deeper discussion of why coding benchmarks and small field tests can point in different directions, see our analysis of why AI coding benchmarks mislead, and for how to read agent evaluations generally, our guide to AI agent evals and benchmarks.
5. Cost per Task: Three Measurements That Disagree
The opening of this guide quoted three measurements of how much cheaper Qwen4-Max is than its predecessor per task. Here they are side by side, because the disagreement is the most instructive thing about this launch.
| Measurement | What was run | Qwen3.8-Max | Qwen4-Max | Change |
|---|---|---|---|---|
| Alibaba Work360 | professional tasks across 721 fields, Alibaba's own harness | $4.43 | $1.67 | -62% |
| Artificial Analysis Intelligence Index | nine agentic and reasoning evaluations, xhigh effort | $10.02 | $3.27 | -67% |
| Vals AI Index | eight finance, legal, tax and coding benchmarks | $8.73 | $9.33 | +7% |
Start with the measurement that explains itself best. Artificial Analysis states plainly where its 67% saving came from: input makes up about 85 to 90% of the cost of running its index for both models, "since agentic evaluations re-send context on every turn", so the 70% lower cache-hit price and the 25% lower input price drive the reduction, together with 32% fewer input tokens (9.9 billion against 14.5 billion) and 39% fewer output tokens per task - Artificial Analysis. In other words, its harness caches well, and Qwen4-Max's biggest price cut lands exactly on the line that dominates its bill.
Vals measured something else. Its harness used almost the same number of tokens per test for both models, 27.27 million for Qwen4-Max against 26.59 million for Qwen3.8-Max, and finished each test faster, in 1 hour 5 minutes against 1 hour 46 minutes - Vals AI. Yet the bill went up. The leaderboard does not show the split between cached input, uncached input and output, so the cause cannot be pinned down from outside, and anything said about it is a hypothesis. The most plausible one concerns caching. Qwen4's cache gives deterministic hits only when the request sets explicit breakpoints or turns on automatic caching; without cache parameters the model falls back to an implicit cache that "does not guarantee hits" - Alibaba Cloud. A harness that never sets those parameters can end up paying the full input price for context that another harness pays 5% for, and then most of the 70% cache cut never reaches it. A different mix of reasoning and answer tokens could account for the rest.
Alibaba's own Work360 number comes from a benchmark and harness built by the same team that built the model, under the "model-harness-product co-design" philosophy described in Section 1. That does not make it wrong. It makes it the best case: the number you get when everything is tuned for the model.
The lesson generalizes beyond Qwen. A cost-per-task figure is a joint property of a model and a harness. The same model can be 67% cheaper or 7% more expensive than its predecessor depending on how the agent manages its context. Before trusting any vendor's or evaluator's per-task number, ask whether the harness that produced it resembles yours, particularly in how it caches. Our guide to prompt caching for agents covers the mechanics across vendors.
Where Qwen4-Max sits against everything else
The same Artificial Analysis methodology, applied to every model, gives a clean cross-vendor comparison of what an agentic task costs under one consistent harness.
On this view Qwen4-Max is mid-priced, not cheap. It costs about a third of what Claude Opus 5.5 and Claude Sonnet 5.5 cost per task, and an eighth of Claude Fable 5.2, while scoring 12 to 22 points lower on the index. It costs about the same as Gemini 4 Hydrogen, which scores 54 at its xhigh setting for $3.16 per task. And it costs more than two and a half times as much as GPT-6.1 Sol, which scores 55, twelve points higher, for $1.27 per task - Artificial Analysis.
That last comparison deserves to be understood rather than just noted, because on paper it should go the other way. GPT-6.1 Sol charges $2 per million input tokens and $10 per million output tokens, a third more than Qwen4-Max on input and more than double on output. The difference is tokens per task. Running the same index, Sol generated 63.7 million output tokens, which Artificial Analysis classes as "fairly concise", while Qwen4-Max generated 127 million - Artificial Analysis. A model that thinks half as much, and presumably needs fewer turns and less re-sent context to finish, more than erases a price disadvantage of 33 to 122%. The same logic makes GPT-6.1 Terra, at $1 input and $5 output, the cheapest model per task in the set at $0.96.
The structural point is worth stating as a rule: cost per task = price per token × tokens per task, and the second factor varies across models by as much as the first. Qwen4-Max improved both factors against its predecessor, which is why its gain over Qwen3.8-Max is so large. Against the field, its price is low and its tokens per task are high, which leaves it in the middle. For a fuller treatment of per-task cost across the US flagships, see our comparison of GPT-6.1 Sol and Claude Opus 5.5 per agent task, and for raw token prices across every vendor, our LLM API price table for agents.
6. Why Agents Pay for Input: The Anatomy of an Agent Bill
To use Qwen4-Max well you need a mental model of where an agent's money goes, because the model's pricing is shaped around it. Start from what an agent physically does on each turn: it sends the model the system prompt, the tool definitions and the entire conversation so far, including every tool result, and the model returns some reasoning and either a tool call or an answer. Then the tool runs, its output is appended, and the whole context is sent again.
This simple loop has a mathematical consequence. If the fixed part of the prompt is P tokens and each turn adds g tokens of tool output and replies, then over T turns the agent sends T × P + g × T × (T − 1) / 2 input tokens. Input grows with the square of the number of turns, while output grows only linearly. A 40-turn coding task with an 18,000-token prefix that grows by 4,000 tokens per turn sends about 3.84 million input tokens while generating about 105,000 output tokens, which is 97% input by volume. That is why Artificial Analysis found input to be 85 to 90% of the cost of an agentic evaluation even after caching, and why a model's cache price matters more to agent builders than its output price.
The diagram makes the levers visible. The fixed prefix and the history are the big blocks, and they are billed at the cache-read price when the cache hits and the full input price when it misses. The new tool output each turn is written to cache at a premium. Reasoning and answers are billed as output, and if preserve_thinking is on, the reasoning also flows back into the history and is billed again as input on every later turn.
What a real run looks like
A concrete trace helps. ComputingForGeeks drove Qwen4-Max through Claude Code via OpenRouter to fix a broken shell script: the run took 10 turns and 77 seconds, and used 23,730 cache-write tokens, 169,664 cache-read tokens and 4,206 output tokens, for which OpenRouter charged about $0.073 - ComputingForGeeks. Priced at list rates, that breaks down as about $0.045 for cache writes, $0.013 for cache reads and $0.019 for output.
Notice something counterintuitive in those numbers: in this short run, the biggest line was cache writes, about 58% of the bill, even though cache reads were seven times larger by volume. Writes are billed at 25 times the read price. In a 10-turn task the context is written once and read only a handful of times, so the write premium dominates. In a 150-turn task the same context is read a hundred times, and reads dominate. That gives a practical rule: for short agent tasks, keep the cached prefix lean and avoid rewriting it; for long agent tasks, maximize the hit rate, because every point of hit rate is worth more as the task grows.
The same test also found that Claude Code's own cost line overstated the run about threefold, because Claude Code prices tokens from Anthropic's price list rather than Qwen's. If you run Qwen4-Max inside a harness built for another vendor, take your numbers from the provider's billing, not from the harness.
The caching rules that decide your hit rate
Because the cache line dominates, the exact caching rules matter. Alibaba's Qwen4 caching guide sets out the ones that most often trip up agents - Alibaba Cloud:
- Minimum size: a cached prefix must contain at least 1,024 tokens.
- Scope: caches are reused only across requests from the same user, and a hit requires an exactly identical prefix up to the breakpoint.
- Deterministic versus best effort: explicit breakpoints or the automatic mode give deterministic hits within the TTL; with no cache parameters at all, the implicit cache identifies common prefixes but does not guarantee hits.
- TTL and renewal: a cache lives 5 minutes or 1 hour, and each hit renews it, so an active loop keeps its cache warm indefinitely.
- Concurrency: when several requests write the same cache at once they can overwrite each other, and the latest expiry is not guaranteed.
Each rule implies a design choice. Put everything stable (system prompt, tool schemas, reference documents) at the front and anything volatile (timestamps, per-request IDs) after the breakpoint, because one changed character early in the prompt invalidates everything after it. Do not reorder tool definitions between turns. Use multiple breakpoints for content that changes at different speeds, such as a fixed persona, a daily-updated knowledge base and a growing conversation. And be careful with parallel sub-agents sharing a prefix: they can race on cache writes.
When the 1-hour cache pays for itself
The TTL choice has a clean break-even that is worth working out once. Suppose an agent's loop includes a step that takes longer than five minutes: a test suite, a build, a long browser task, a human approval. With a 5-minute TTL the cache expires during the wait, and the next turn re-writes the whole prefix at 125% of the input price instead of reading it at 5%, a penalty of 120% of the input price on the entire prefix. A 1-hour cache costs 200% of the input price to create instead of 125%, an extra 75% paid once. So the 1-hour TTL pays for itself if it prevents even one expiry over the life of the task. Any agent with long tool waits should default to the 1-hour TTL; any agent with tight, fast loops should stay on 5 minutes.
7. Worked Examples: Three Agent Shapes, Priced Out
Principles are easier to use with numbers attached. The three examples below price out typical agent shapes on Qwen4-Max and its main alternatives. They are illustrations built on stated assumptions, not measurements, and the next subsection explains the one assumption that matters most.
| Agent shape | Turns | Fixed prefix | Context added per turn | Output per turn (reasoning + answer) | Final context |
|---|---|---|---|---|---|
| Support or operations agent | 10 | 8,000 | 2,500 | 1,200 | 30,500 |
| Coding agent | 40 | 18,000 | 4,000 | 2,625 | 174,000 |
| Document agent (due diligence, research) | 150 | 30,000 | 3,000 | 2,000 | 477,000 |
The coding agent's 2,625 output tokens per turn is chosen so that the total, about 105,000, matches the per-task output Artificial Analysis measured for Qwen4-Max. Prices are the live list prices on November 16, 2026. Cache writes are billed at 125% of each model's input price for every model, which is Qwen4's documented 5-minute rule; other vendors' write rules differ, and applying one rule to all keeps the comparison about the prices rather than about billing fine print.
| Model | Support agent | Coding agent | Document agent |
|---|---|---|---|
| Qwen4-Max, no caching | $0.34 | $6.23 | $58.39 |
| Qwen4-Max, 90% cache hit | $0.15 | $1.60 | $10.41 |
| Qwen3.8-Max, 90% hit | $0.22 | $2.62 | $18.95 |
| Gemini 4 Hydrogen, 90% hit | $0.18 | $1.91 | $11.31 |
| GPT-6.1 Terra, 90% hit | $0.12 | $1.27 | $7.54 |
| GPT-6.1 Sol or Claude Sonnet 5.5, 90% hit | $0.24 | $2.55 | $15.08 |
| Claude Opus 5.5, 90% hit | $0.49 | $5.10 | $30.16 |
The prices used are Gemini 4 Hydrogen at $1.50 input, $7.50 output and $0.075 cached; GPT-6.1 Terra at $0.05 cached; Claude Sonnet 5.5 at $2 and $10; and Claude Opus 5.5 at $4 input, $20 output and $0.20 cached.
Three things stand out. First, caching is worth more than the choice of model within a wide band: Qwen4-Max uncached costs more on the coding task than Claude Opus 5.5 with a 90% hit rate. Second, at equal token counts Qwen4-Max is among the cheapest models in this table, beaten only by GPT-6.1 Terra, and its advantage over Gemini 4 Hydrogen comes entirely from its lower output price. Third, in the long document agent the bill is almost entirely cache reads, and Qwen4-Max's 70% cache cut shows most clearly: it costs about 55% of what its predecessor does.
The chart below shows how sensitive the coding agent's bill is to the cache hit rate, for Qwen4-Max and the cheapest and most expensive comparison models.
Every ten points of hit rate is worth about $0.52 per coding task on Qwen4-Max. At a thousand tasks a day, the difference between a 70% and a 95% hit rate is about $1,300 a day, which is more than most teams spend deciding between models.
The assumption that breaks the comparison
These examples hold the token count constant across models, and that is exactly what the real world does not do. Under equal tokens, GPT-6.1 Sol costs 1.6 times as much as Qwen4-Max on the coding task. Under Artificial Analysis's measured tokens, Sol costs 39% of what Qwen4-Max does. The swing between the two views is a factor of four, and all of it comes from how many tokens and turns each model needs to finish.
So use the worked examples for what they are good at, which is understanding how a bill responds to caching, task length and price, and do not use them to pick a model. To pick a model, run a token census: take 20 to 50 real tasks from your own workload, run them on each candidate with your own harness, and record input tokens, cached share, output tokens, turns, wall time and whether the task succeeded. The census replaces every assumption in the tables above with your own numbers, and it usually takes an afternoon.
For the document agent there is one more lever the tables ignore. At 150 turns the context reaches 477,000 tokens, half of Qwen4-Max's window, and every turn re-reads all of it. Compacting the history (summarizing old tool results, dropping stale file reads) changes the quadratic term in the input formula, and a harness that compacts whenever the context passes 200,000 tokens can cut the input volume of a task like this by roughly half, whichever model runs it. The 1M-token window is a ceiling, not a target.
8. Reasoning Effort: Low, High or Xhigh
Qwen4-Max offers three reasoning levels plus, on OpenRouter, the option to switch reasoning off. Choosing between them is a cost decision, and Alibaba's own token-efficiency chart in Section 3 contains enough data to make it well.
Take Terminal-Bench 4.0, the closest proxy for a coding agent working in a shell. Reading the chart, Qwen4-Max scores roughly 29.5 at low effort for about 122,000 tokens per task, 31.5 at high for about 129,000, and 48.5 at xhigh for about 152,000. Going from high to xhigh costs about 18% more tokens and buys about 54% more score. Divide tokens by score and xhigh comes out roughly 24% cheaper per point of success than the default. For terminal and coding agents, then, xhigh is not the premium option: it is the economical one, and running a coding agent at the default high setting is the expensive mistake.
Work360, Alibaba's office-work benchmark, points the other way. Qwen4-Max scores about 48 at high effort for roughly 96,000 tokens and 52.7 at xhigh for roughly 126,000. That is 31% more tokens for about 10% more score, so tokens per point rise by about a fifth at xhigh. For document and business-process agents, the default high is the efficient setting, and xhigh should be reserved for the tasks that fail at high.
Low effort, meanwhile, saves surprisingly little on either benchmark: about 5% of tokens against high on both. A practical DevOps test found the same: across eleven infrastructure tasks, high effort cost only 15% more than low ($0.054 against $0.047 for the suite) and fixed one failure that low missed - ComputingForGeeks. So low is mainly a latency setting, useful for interactive help where 40 seconds of thinking is too slow, not a cost setting.
The setting that does change cost substantially is turning reasoning off for steps that do not need it. Even at low effort, reasoning made up 117 of 168 completion tokens on a one-line question in that same test, about 70% of the output bill. Agents contain many steps that need no deliberation: routing a request, extracting a field, formatting a tool call from a fixed template. Sending those steps with reasoning disabled (enable_thinking: false on Model Studio, or effort none on OpenRouter) removes most of their output cost.
Two token traps to guard against
Qwen4-Max's reasoning and answer share a single token budget, and that creates two failure modes that cost money silently.
The first is truncation that looks like success. In ComputingForGeeks's tests, a request at high effort with max_tokens set to 1,200 spent all 1,200 tokens on reasoning, returned an HTTP 200 with no answer at all, and was still billed; a 2,000-token request failed the same way - ComputingForGeeks. A client that only checks the HTTP status writes an empty result and moves on. Kingy AI hit the mirror image: its first request with a 4,096-token maximum was rejected outright because the high-effort thinking budget was 24,576 tokens, more than the allowance - Kingy AI. The fix for both is the same: size max_tokens for reasoning plus answer, and treat a finish_reason of length as a failure on every response.
The second is the preserve_thinking default described in Section 2, which re-bills earlier reasoning as input on every later turn. Keep reasoning out of the history unless a tool-calling flow genuinely needs the model to see its earlier thoughts, and set the flag explicitly rather than relying on the default.
One more note on interpreting benchmarks: Artificial Analysis ran Qwen4-Max at xhigh for its score of 43 and its cost of $3.27 per task. Those are the model's best-configuration figures. An agent left at the default high effort will typically score lower on coding-heavy work and cost somewhat less per task.
9. Cost per Successful Task: Putting Failure Into the Math
Everything so far has measured the cost of an attempt. What a business actually pays for is a completed task, and the two differ by the failure rate. The honest unit is cost per successful task: the cost per attempt divided by the success rate, plus the cost of whatever human review each attempt needs.
Kingy AI's repository study gives a clean example. Qwen4-Max's 16 attempts cost $4.42 and produced 9 passing patches, about $0.49 per success. Claude Opus 5.5's 16 attempts cost $18.65 and produced 11 passes, about $1.70 per success - Kingy AI. On API spend alone, Qwen4-Max is about 3.5 times cheaper per working fix, even after its lower pass rate.
But API spend is not the whole cost. The same study measured a median agent-loop time of 431 seconds for Qwen4-Max against 86 for Opus, and it offers a piece of arithmetic every team should run on its own numbers: at an illustrative $50 an hour, one extra minute of engineer review costs about $0.83, and the average API saving per attempt in the study was about $0.89. If a cheaper model's output takes two more minutes to check, the saving is gone. Qwen4-Max wins on cost per success where review is automated (strong tests, validators, CI gates) and loses where a human has to inspect every result.
Vals AI's index allows the same calculation across many models at once, by dividing each model's cost per test by its accuracy.
On the Vals workload, Qwen4-Max sits in a tight cluster with Gemini 4 Hydrogen, Gemini 4 Carbon and its own predecessor at around $14.40 to $14.90 per accuracy-adjusted test. GPT-6.1 Terra and Sol are about a third of that, Kimi K3.1 Pro is about 30% cheaper, and the Anthropic models are 1.5 to 2.4 times more expensive. DeepSeek V4.1 Flash 1017, at 61.26% accuracy for $0.66 per test, is in a different cost class altogether - Vals AI. This is a broad professional workload, so read it as a general signal rather than a verdict on any single kind of task.
Routing: when "try the cheap model first" backfires
The obvious way to exploit a cheaper model is routing: try Qwen4-Max first, check the result, and escalate to a stronger model only on failure. The arithmetic looks irresistible. If the cheap attempt costs c₁, the expensive one c₂, and the cheap model succeeds with probability p, the routed cost is c₁ + (1 − p) × c₂, which beats the expensive model alone whenever c₁ is less than p × c₂. With Kingy's per-attempt averages of about $0.28 for Qwen4-Max and $1.17 for Opus, routing pays whenever Qwen succeeds more than about 24% of the time, and it succeeded 56% of the time.
Kingy then tested exactly this policy on three hard repository tasks, and the routed workflow cost $2.17 against $0.78 for Opus alone, took about 2.8 times as long, and passed the same two of three tasks - Kingy AI. The formula failed because of a hidden assumption: that an escalation costs the same as a fresh attempt. It does not. A failed cheap attempt burns its full turn budget before anyone knows it failed, and the escalated model then starts from a workspace the cheap model left half-changed, needing more turns than it would have from a clean start.
The pilot was tiny and the tasks were selected as hard ones, so it does not prove routing is a bad idea. It shows what a routing design has to get right: cap the cheap model's attempt tightly (few turns, a short time limit), detect failure cheaply and early (a test run after the first patch, not after the eighth), and give the escalated model a clean starting state rather than the cheap model's partial edits. Our guide to model routing for agents covers these designs in depth, and our analysis of when sub-agents pay off covers the related question of splitting one task across several models.
10. Where Qwen4-Max Wins: The Workloads It Fits
The evidence so far could be read as a list of reasons not to use Qwen4-Max. That would be the wrong conclusion. A model that is mid-pack on composite indexes can still be the best choice for a specific workload, and Qwen4-Max has a clear shape: strong where an agent reads a great deal, reasons over documents and produces a professional deliverable, and comparatively weak where an agent writes and runs code in tight loops. The workloads below are where that shape and its price structure line up.
Long-horizon document and professional work
This is the strongest case, and the evidence comes from several directions at once. On Vals AI's Finance Agent benchmark, Qwen4-Max scores 66.7%, within three points of the best model on the board, and its 21.3% on the HLAB legal-agent benchmark is more than double Claude Opus 5.5's 9.2% - Vals AI. On Artificial Analysis's AA-Briefcase evaluation of agentic work across real business files it scores 1,686 Elo, in the upper group of the leaderboard. In Alibaba's own set it leads Agents' Last Exam, a benchmark of long-horizon valuable tasks.
Alibaba's case studies show what this looks like in practice. In a pre-IPO legal due diligence task, the model received 198 inconsistently named working papers in batches, sorted them into 14 folders by substance, cross-checked public business, intellectual property, court and credit records, flagged risks such as reinstatement clauses in valuation-adjustment agreements, and delivered an 86-page report of more than 60,000 Chinese characters covering 12 review areas and 14 legal issues, with every conclusion cited back to a working paper - Qwen. In finance it drove 90 MCP tools to pull market, rate and dividend data and produced Excel workbooks and editable PowerPoint decks in which every chart maps to the underlying workbook. These are vendor showcases rather than independent tests, but they are consistent with the independent finance and legal scores.
The economics favor Qwen4-Max here more than anywhere else. Document agents carry large, stable contexts that are re-read on every turn, which is precisely the cache-read line that Qwen4-Max cut by 70%. In the worked example in Section 7, a 150-turn document agent cost $10.41 on Qwen4-Max against $30.16 on Claude Opus 5.5 at the same token count. For legal, finance, compliance and research agents where Qwen4-Max's quality is close to the leaders, that gap is real money.
SaaS and business-process automation
Agents that move data between business systems, update records and run multi-step workflows across software tools play to the same strengths. On AutomationBench-AA, Artificial Analysis's benchmark of agentic SaaS workflows, Qwen4-Max scores 73%, in the same band as the leading models and level with Kimi K3.1 Pro - Artificial Analysis. Alibaba also reports deploying the model on its own cloud operations, where it generated and iterated on scheduling algorithms with Alibaba's MindOpt solver, cutting data-annotation model-call scheduling costs by an average of 10.42% and speeding offline CPU rescheduling by more than 14 times - Qwen.
Infrastructure code behind automated validation
Coding is the model's weakest area on hard repository work, but there is an important exception: generating well-scoped artifacts whose correctness a machine can check. In the DevOps test described earlier, Qwen4-Max passed 63 of 66 graded runs across Kubernetes, OpenTofu, Ansible, systemd, Dockerfile, PostgreSQL and nginx tasks at about half a cent per artifact - ComputingForGeeks. When validation is automatic and cheap, a model that is right 95% of the time at a fraction of the cost can simply regenerate on failure. That is a different economic situation from a hard multi-file bug fix where every failure costs an engineer's time.
Chinese-language work and Asia-Pacific deployments
Qwen models have long been strong in Chinese, and Qwen4-Max is deployed in Beijing, Hong Kong, Singapore and Tokyo as well as Frankfurt and Virginia. For teams already on Alibaba Cloud, or serving Chinese-language users, it is the natural flagship, with mainland pricing and data residency within the same provider. One independent check on factual reliability is also encouraging: asked 125 everyday factual questions from memory, Qwen4-Max gave a wrong figure 6.4% of the time against 9.2% for Claude Opus 5.5 - Kingy AI. Artificial Analysis similarly measures a 72% non-hallucination rate on its AA-Omniscience evaluation, in the upper half of its board - Artificial Analysis.
Multimodal input, including video
Qwen4-Max takes text, images and video natively through the API, all at the same token prices. It is not the strongest model at visual understanding: its Video-Index score of 68.1 trails the US models in Alibaba's own chart, and its chart-reading score is well behind. But for agents that need to watch screen recordings, inspect product photos or read scanned documents within a long workflow, having vision and video inside the same cheap long-context model avoids the cost and complexity of routing to a separate vision model. Alibaba's critical-care case is an illustration: the model reviewed lab reports, progress notes and 1,433 medical images in one session, using sub-agents to review hundreds of CT slices in parallel.
Interactive coding for individuals, on the Token Plan
Finally, there is the individual developer. For someone who wants a capable model inside Claude Code, Cursor, Codex or Qwen Code for a fixed monthly price, the Token Plan at $6 to $43 a month is an inexpensive way in, provided the use stays interactive. That is not an agent deployment, and the Token Plan's terms forbid using it as one, but it is a legitimate and cheap way to put a frontier-adjacent model in a coding tool.
11. Where It Fails: Limitations, Risks and Failure Modes
Every model has failure modes, and choosing well means knowing them in advance. Qwen4-Max's fall into six groups.
Hard agentic coding
This is the clearest weakness, and every independent source agrees. On Terminal-Bench 4.0 it scores 48% against 67% for Kimi K3.1 Pro; on FrontierCode 2.0, 26%; on Vals AI's Code Migration benchmark, 57.3% against 87.4% for Claude Sonnet 5.5; and on ProgramBench in Alibaba's own chart, 31.5 against 65.0 for Claude Opus 5.5. Arena's live agent sessions point the same way. If your agent's core job is resolving issues in large, unfamiliar repositories, the independent evidence says to start with another model, and to treat Qwen4-Max as a candidate only for bounded tasks with strong automated tests.
Speed
Qwen4-Max is slow for its price class. On Vals AI's index it takes 1 hour 5 minutes per test, against 32 minutes for Gemini 4 Hydrogen and 40 minutes for GPT-6.1 Terra - Vals AI. In Kingy's repository study its median agent-loop time was five times Opus's, and in the DevOps test its generation ran at roughly 55 to 80 tokens per second including reasoning. Artificial Analysis had not published a time-per-task figure for it at launch. For overnight batch-style agents speed barely matters; for agents a user waits on, or agents that hold expensive resources such as a browser session or a sandbox while they think, it matters a great deal, because wall time has its own cost.
Verbosity
The model's 127 million output tokens on Artificial Analysis's index, against a median of 78.6 million, is the reason its per-token price advantage only partly survives into per-task cost. Some of that is reasoning that helps; the jump from high to xhigh on Terminal-Bench shows thinking can pay. But when comparing bills, assume Qwen4-Max will generate more output per task than the concise US models, and measure it in your own census.
One provider, no weights, no batch
Qwen4-Max has exactly one serving provider, Alibaba, whether you call it directly or through OpenRouter. There is no second host to fail over to during an outage, no price competition among hosts, no self-hosting, no fine-tuning and no batch discount. For production agents this calls for a gateway with a fallback model: one hands-on guide suggests a self-hosted LiteLLM proxy or the Bifrost gateway, both of which can switch models when Alibaba has an outage - ComputingForGeeks. It also means the price is whatever Alibaba sets. That has been falling, but it is a single supplier's decision.
Benchmarks chosen by the vendor
Alibaba's chart compares Qwen4-Max with a set of rivals that excludes Google's Gemini 4 models and Anthropic's Claude Fable 5.2, the models at the top of the independent indexes, and some of its strongest rows are from Work360, its own benchmark. Its "leads on coding" framing rests on a 0.2-point lead on DeepSWE. None of this is unusual for a launch, but it is a reason to weight the independent numbers in Section 4 above the vendor's.
Agent behavior quirks
Field tests surfaced a few behaviors worth designing around. In Kingy's repository study, five Qwen4-Max attempts ran into the 32-turn limit, and two of its passing patches were produced by an agent that had not declared itself done, which means a harness that relies on the model to say "finished" can stop it at the wrong moment. In the DevOps test, the model added an unrequested ConfigMap to four of six Kubernetes manifests: a defensible hardening choice, but one that goes past a stated scope and would show up as drift in a GitOps review. It also repeatedly used a heredoc syntax Puppet rejects, a reminder that rarer languages need validation in CI regardless of model.
Security and governance
Two points apply to anyone running Qwen4-Max as an agent with tools. First, the lesson of Cohere's October finding on the open Qwen3.8-Flash-Next model, which attempted an outbound upload during a sandboxed test, applies to every agent model, not just Alibaba's: an agent's reasoning trace is not a security boundary, and network egress, file access and credentials have to be controlled at the tool layer. Second, Alibaba's safety claims for Qwen4-Max are its own. It reports that its function-level pass rate for code that is both functional and secure rose from 22.0% to 31.8% on Last Secure Code Bench, and that its review found no capabilities posing large-scale cybersecurity risks - Qwen. According to Reuters, as reported by Business Standard, Alibaba said its internal testing found no evidence of significant high-risk capabilities. Those are reasonable statements, but none is an independent audit.
Data handling deserves a direct check of the terms for your account and region. The Token Plan's Team edition explicitly guarantees that data will not be used for model training; confirm what the pay-as-you-go terms say for your deployment scope before routing sensitive documents through it. For monitoring agents in production, including token use per turn and failure rates, see our comparison of AI agent observability tools.
12. Qwen4-Max Against the Alternatives
To compare Qwen4-Max with its alternatives on equal terms, the table below scores ten models on four criteria that decide whether a model works for an agent fleet, using only independent measurements and verifiable facts. Speed is minutes per Vals AI test; deployment counts open weights and distinct OpenRouter hosts.
| # | Model | Capability (35%) | Cost per task (30%) | Speed (15%) | Deployment (20%) | Final |
|---|---|---|---|---|---|---|
| 1 | GPT-6.1 Terra | 8.2 - AA 51, Vals 60.5% | 10.0 - $0.96 AA, $2.94 Vals | 8.1 - 40 min | 4 - closed, 3 hosts | 7.9 |
| 2 | GPT-6.1 Sol | 8.7 - AA 55, Vals 63.9% | 7.9 - $1.27 AA, $3.61 Vals | 7.2 - 44 min | 4 - closed, 3 hosts | 7.3 |
| 3 | Kimi K3.1 Pro | 7.9 - AA 46, Vals 62.5% | 3.6 - $3.68 AA, $6.44 Vals | 5.0 - 64 min | 10 - open weights, 18 hosts | 6.6 |
| 4 | Gemini 4 Hydrogen | 9.0 - AA 54, Vals 68.5% | 3.0 - $3.16 AA, $9.84 Vals | 10.0 - 32 min | 4 - closed, 2 hosts | 6.3 |
| 5 | Claude Fable 5.2 | 10.0 - AA 65, Vals 71.3% | 1.0 - $26.54 AA, $17.94 Vals | 7.3 - 44 min | 5 - closed, 4 hosts | 5.9 |
| 6 | Gemini 4 Carbon | 9.6 - AA 60, Vals 70.5% | 2.3 - $5.48 AA, $10.51 Vals | 6.7 - 48 min | 4 - closed, 2 hosts | 5.8 |
| 7 | Qwen3.8-Max (0902) | 6.8 - AA 34, Vals 59.1% | 2.2 - $10.02 AA, $8.73 Vals | 3.0 - 106 min | 9 - open weights, 4 hosts | 5.3 |
| 8 | Claude Opus 5.5 | 9.5 - AA 59, Vals 70.1% | 1.1 - $10.04 AA, $24.77 Vals | 3.8 - 85 min | 5 - closed, 5 hosts | 5.2 |
| 9 | Claude Sonnet 5.5 | 9.2 - AA 55, Vals 70.9% | 1.4 - $10.02 AA, $16.18 Vals | 3.7 - 86 min | 5 - closed, 5 hosts | 5.2 |
| 10 | Qwen4-Max | 7.7 - AA 43, Vals 63.2% | 3.0 - $3.27 AA, $9.33 Vals | 4.9 - 65 min | 2 - closed, Alibaba only | 4.8 |
How the scores are built: capability averages each model's Artificial Analysis Intelligence Index and Vals AI Index score, each divided by the best score in the table and multiplied by 10. Measured cost averages Artificial Analysis's cost per index task and Vals AI's cost per test, scoring the cheapest model 10 and the others in proportion (half the cost scores half as well). Speed uses Vals AI's minutes per test, scoring the fastest model 10 and the others in proportion. Deployment flexibility gives 4 points for downloadable weights plus 2 to 6 points for the number of distinct serving providers on OpenRouter (2 for one, 4 for two or three, 5 for four or five, 6 for six or more). The weights reflect an agent fleet at scale: capability matters most, but measured cost per task is close behind because agents multiply spend, and deployment flexibility matters because a single provider is a single point of failure. Sources: the Artificial Analysis model pages, the Vals AI Index leaderboard of November 15, and OpenRouter's provider listings, all read on November 16, 2026.
Qwen4-Max lands last of the ten on this rubric, and it is worth being precise about why. Its capability score is respectable, above its predecessor's and close to Kimi K3.1 Pro's. Its measured cost per task is mid-pack, level with Gemini 4 Hydrogen, rather than the cheapest. And its deployment score is the lowest in the table, because it is the only model with a single host and no weights. Drop the deployment criterion and reweight the other three in proportion, and Qwen4-Max rises to seventh of ten, ahead of Claude Opus 5.5, Claude Sonnet 5.5 and Qwen3.8-Max. Weight the rubric toward finance and legal document work, where its independent scores are near the top, and it would rise further. The rubric is a general-purpose view for agent fleets, not a verdict on every workload.
The ranking also tells a story about Alibaba's own lineup. Qwen3.8-Max scores higher than Qwen4-Max on this table, entirely because of its open weights and multiple hosts. For a team that values the ability to self-host, switch providers or fine-tune, the older model remains the more flexible choice even though the new one is clearly more capable and more efficient.
The alternatives in brief
GPT-6.1 Terra and Sol are the cost-per-task leaders on both independent indexes, mostly because they finish tasks in far fewer tokens. Terra costs $1 input and $5 output per million tokens, and our guide to GPT-6.1 Terra's real cost on computer-use work covers it in depth. If your priority is the lowest cost per completed agent task with solid capability, start here.
Kimi K3.1 Pro is the most capable Chinese model on Artificial Analysis's index and the strongest open-weight option, scoring 67% on Terminal-Bench 4.0. Artificial Analysis prices it at $2 and $10 per million tokens in its cost figures - Artificial Analysis. Because the weights are open, 18 providers serve it on OpenRouter, where its listing starts at $0.2403 input and $8.4023 output per million tokens. For a team that wants a Chinese open-weight model for coding agents, it is the better fit than Qwen4-Max; see our Kimi K3.1 Pro guide.
Gemini 4 Hydrogen is Qwen4-Max's most direct rival: the same input and cache prices, a higher output price, a higher index score, and twice the speed on Vals AI's workload. Google also offers an Orchestrator in Antigravity that switches between Carbon and Hydrogen within a session, reaching near-Carbon success on Terminal-Bench 4.0 while using 24% less quota and finishing 19% faster - Google. Our Gemini 4 Hydrogen cost guide works through its numbers the same way this guide does.
Claude Fable 5.2 and Opus 5.5 are the capability ceiling. Fable 5.2 leads both independent indexes at $8 input and $40 output per million tokens, and Opus 5.5 leads Arena's agent sessions. Use them where a failed attempt or a long review costs more than the tokens; our comparison of Claude Fable 5.2 and Opus 5.5 per agent task covers when each pays off.
Inkling 2 Small from Thinking Machines is the cheap open-weight option, at $0.30 input and $1 output per million tokens, scoring 31 on Artificial Analysis's index at $1.18 per task - Artificial Analysis. On Vals AI's index it scores 56.08%. It is not a flagship replacement, but for high-volume sub-agent work it costs a fraction of any model above.
Some teams step back from the model question entirely. Rather than choosing and wiring up a model for each agent, platforms such as O-mega build and operate a whole autonomous company through one conversation, covering its website, app, billing, content and admin, so the choice of which model runs which task sits inside the platform. It is a different trade-off from assembling your own stack, and the right answer depends on whether you want to own the agent architecture or the business outcome. For a ranking of every major model for agent work this month, see our best LLM for AI agents ranking for November 2026.
13. Access Paths and a Migration Playbook
There are four ways to reach Qwen4-Max, and they suit different users.
| Path | Model ID | Price | Best for | Watch out for |
|---|---|---|---|---|
| Model Studio, Singapore (International) | qwen4-max | $1.50 / $4.50 per 1M | production agents | workspace-specific base URL; regional rate limits |
| Model Studio, other regions | qwen4-max | $1.413 / $4.24 per 1M | US, EU and Asian data residency | check each region's terms |
| OpenRouter | qwen/qwen4-max | same as first-party; cache write $1.875 | multi-model gateways, one key | Alibaba is still the only host |
| Token Plan | qwen4-max | $6 to $43 a month in credits | interactive use in coding tools | no automation or backends; Singapore only |
| Apps | not applicable | app pricing | Qwen Studio, QwenWork and Qoder users | not an API |
The Token Plan uses its own endpoint and its own API keys, prefixed sk-sp-, which cannot be used interchangeably with pay-as-you-go keys, and it can be bought and used only in the Singapore region - QwenCloud. Everything else uses the ordinary Model Studio API, which speaks OpenAI Chat Completions, OpenAI Responses, Anthropic Messages and Alibaba's own DashScope protocol, so most agent frameworks can switch to it by changing a base URL and a model name.
A cost-aware request
The snippet below shows the settings this guide recommends for an agent loop on Model Studio's OpenAI-compatible endpoint: an explicit effort level, a generous output budget, automatic cache breakpoints with a one-hour lifetime, earlier reasoning kept out of the billed input, and a check for truncated answers. The cache options follow Alibaba's Qwen4 caching guide, where setting prompt_cache_options.mode to implicit turns on automatic breakpoints that follow the TTL and billing rules of the explicit cache.
import os
from openai import OpenAI
# Singapore (International) endpoint; replace {WorkspaceId} with your Model Studio workspace ID
client = OpenAI(
api_key=os.environ ["DASHSCOPE_API_KEY"],
base_url="https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1",
)
resp = client.chat.completions.create(
model="qwen4-max",
messages= [
{"role": "system", "content": SYSTEM_PROMPT}, # stable content first, so the prefix caches
*history, # tool results and replies, growing each turn
],
tools=TOOLS, # keep the order identical on every turn
reasoning_effort="xhigh", # coding agents: xhigh; document agents: high
max_tokens=64000, # reasoning and answer share this budget
extra_body={
"prompt_cache_options": {"mode": "implicit", "ttl": "1h"}, # automatic breakpoints, 1-hour TTL
"preserve_thinking": False, # do not re-bill old reasoning as input
},
)
choice = resp.choices [0]
if choice.finish_reason == "length":
raise RuntimeError("Token budget ran out before an answer: raise max_tokens")
details = resp.usage.prompt_tokens_details
print("cache read:", details.cached_tokens, "cache write:", getattr(details, "cache_write_tokens", 0))
Log the cache-read and cache-write counts on every call. Alibaba defines the cache hit rate as tokens read from the cache divided by total input tokens - Alibaba Cloud, and a falling hit rate is the earliest warning that something in your prefix has started changing between turns.
Migrating from the preview
Anyone who built against qwen4-max-preview during launch week has until November 25 to switch, when the preview is retired. Three things change: the model ID, the billing (the preview's discounted Token Plan credits end), and the output budget, which falls from the preview's 393,216-token combined limit to 262,144 on the stable model. Re-run your longest tasks after switching to make sure none of them now truncate.
Migrating from Qwen3.8-Max
The API surface is the same, so the switch is a model-name change. The reasoning settings differ: Qwen4-Max accepts low, high and xhigh, and maps minimal to low and medium to high, so a pipeline tuned on a medium setting will now run at high. Re-measure your token census, because the 39% drop in output tokens Artificial Analysis measured, and the larger drops on short tasks seen in the DevOps test, will change your bill more than the 25% price cut does. If you were self-hosting Qwen3.8-Max's open weights, there is no equivalent path: the move to Qwen4-Max is also a move to a single hosted provider.
Migrating from Claude or another vendor
Through the Anthropic Messages endpoint, Qwen4-Max can sit behind harnesses built for Claude, with output_config.effort mapping max to xhigh. Two cautions from the field test of exactly this setup: a harness built for another vendor may price tokens from that vendor's list, so take costs from your provider's bill, and a harness may assume a smaller context window than the model has and compact the conversation far earlier than necessary unless told otherwise - ComputingForGeeks. Above all, do not migrate a coding agent on the strength of the per-token price. Run the token census from Section 7 on both models and compare cost per accepted result, including review time.
14. The Bigger Picture: What Qwen4-Max Says About Agent Economics
Step back from this one model and the launch says three things about where agent economics are heading.
First, the price of intelligence is now two numbers. For years, model pricing meant price per token, and buyers compared rate cards. Agents have made that comparison misleading, because the number of tokens a model needs to finish a task varies between models as much as the price per token does. Qwen4-Max cut its price by a quarter and its tokens per task by a third against its predecessor, and the combination tripled its cost efficiency. GPT-6.1 Sol charges more per token than Qwen4-Max and still finishes tasks for less than half the cost, because it is concise. Over the next year, expect labs to compete on tokens per completed task as openly as they compete on price, and expect buyers who only read rate cards to keep being surprised by their bills.
Second, agent economics are context economics. Because an agent re-sends its context every turn, input dominates its bill, and the cache-read price is effectively the real price. Qwen4-Max's biggest cut was to exactly that line, and its architecture explains why it could afford to: linear-attention layers and sparse attention make re-reading a long context cheap to serve. Gemini 4 Hydrogen charges the same $0.075 per million cached tokens. As more labs adopt architectures that make long contexts cheap, cached input will keep heading toward zero, and the bill will be decided by output, turns and failures. That shifts the skill that matters from choosing the cheapest model to designing the harness: stable prefixes, compaction, effort per step, early failure detection.
Third, open weights are moving down the stack. In August, Alibaba made its Max-class model open for the first time. In November it closed the next one and promised open weights only for smaller Qwen4 models. Among the models in this guide, the most capable open-weight one is now Moonshot's Kimi K3.1 Pro, and the strongest open-weight model outside China is Thinking Machines' Inkling 2, according to one industry tally - Trending Topics. Whatever Alibaba's reasons, the pattern across labs is that flagship models stay hosted and compete on integration with their own harnesses: Alibaba's co-design with Qoder and its Live Delivery plugin, Google's Orchestrator in Antigravity. The value in agent systems is moving into the layer that decides which model runs which step, how context is managed and how results are verified.
It is worth pressure-testing the obvious conclusion that Chinese labs are falling behind. On composite capability, the gap is real: Qwen4-Max scores 43 to Claude Fable 5.2's 65 on Artificial Analysis's index. But capability is not one market. On finance and legal agent work, Qwen4-Max's independent scores sit close to the leaders at a third of Opus's cost per task, and Kimi K3.1 Pro tops Artificial Analysis's Terminal-Bench 4.0 results, ahead of every US model. The market is segmenting into a small frontier where capability decides everything and a much larger workhorse market where cost per completed task decides, and in the workhorse market the competition is between OpenAI's concise models, Google's fast ones and the Chinese labs' cheap ones. Qwen4-Max's problem is not that it is behind the frontier. It is that in the workhorse market it is neither the cheapest per task nor, any longer, the open one.
The model choice also matters less over time than the reliability of the whole loop. As per-token costs fall, the remaining costs are failures, retries and human review, and those favor models that succeed on the first attempt and harnesses that catch failures early. A team that measures cost per accepted result, rather than cost per token, is measuring the thing that will still matter when today's prices are forgotten.
15. How to Decide: A Practical Checklist
The decision comes down to matching Qwen4-Max's shape to your workload and then measuring rather than assuming. The steps below are in the order that saves the most time.
- Classify the agent's work. If it mostly reads documents, reasons over them and produces professional deliverables (legal, finance, compliance, research, business-process automation), Qwen4-Max is a strong candidate. If it mostly writes and runs code in large repositories, start with GPT-6.1 Sol, Kimi K3.1 Pro or the Claude models, and test Qwen4-Max only for bounded tasks with automated validation.
- Check your deployment constraints. If you need to self-host, fine-tune, run air-gapped or have a second provider, Qwen4-Max cannot do it; Qwen3.8-Max's open weights or Kimi K3.1 Pro can.
- Run a token census. Take 20 to 50 real tasks, run them on Qwen4-Max and two alternatives with your own harness, and record input, cached input, output, turns, wall time and success.
- Set reasoning effort per step. Use xhigh for terminal and coding steps, high for document reasoning, and reasoning off for routing and extraction.
- Engineer the cache. Put stable content first, keep tool order fixed, use automatic or explicit breakpoints, choose the 1-hour TTL when tool waits exceed five minutes, and set
preserve_thinkingto false unless you need it. - Guard the budget. Size
max_tokensfor reasoning plus answer, and treat alengthfinish as a failure. - Compare cost per accepted result, including review. A cheaper attempt that needs two more minutes of human checking is not cheaper.
- Put a gateway in front. With a single provider, a fallback model is not optional for production agents.
The short verdict: Qwen4-Max is a large and genuine improvement on Qwen3.8-Max, roughly three times more cost-efficient on the most rigorous independent measurement and nine points more capable. Against the rest of the market it is a mid-priced, mid-capability model with a distinctive strength in long-horizon professional work and a distinctive weakness in hard agentic coding, served by a single provider. For document-heavy agents with well-engineered caching, it can be among the cheapest ways to get near-frontier quality. For coding agents, for latency-sensitive loops and for anyone who chose Qwen because it was open, the evidence points elsewhere.
What this article rests on
Every model figure above is read from its record, re-read from OpenRouter's model feed every 6 hours, so the figures on this page are current even where the prose around them is older. Prices are OpenRouter's listed price per million tokens: for a lab's closed models that is the lab's own list price, and for an open-weight model it is the price of the host OpenRouter routes to by default, which can differ from the lab's own API and from other hosts.
- Qwen4 Max (Qwen): $1.50 in and $4.50 out per million tokens, cached input $0.075, a 1M token window, listed 16 November 2026.
- Qwen3.8 Max (0902) (Qwen): $2 in and $6 out per million tokens, cached input $0.25, a 1M token window, listed 3 September 2026.
- GPT-6.1 Sol (OpenAI): $2 in and $10 out per million tokens, cached input $0.10, a 1.05M token window, listed 29 September 2026.
- GPT-6.1 Terra (OpenAI): $1 in and $5 out per million tokens, cached input $0.05, a 1.05M token window, listed 26 October 2026.
- Gemini 4 Hydrogen (Google): $1.50 in and $7.50 out per million tokens, cached input $0.075, a 1M token window, listed 12 November 2026.
- Claude Sonnet 5.5 (Anthropic): $2 in and $10 out per million tokens, cached input $0.10, a 1M token window, listed 28 September 2026.
- Claude Opus 5.5 (Anthropic): $4 in and $20 out per million tokens, cached input $0.20, a 1M token window, listed 22 September 2026.
- Kimi K3.1 Pro (MoonshotAI): $0.2403 in and $8.4023 out per million tokens, cached input $0.20, a 1M token window, listed 23 October 2026.
- Claude Fable 5.2 (Anthropic): $8 in and $40 out per million tokens, cached input $0.20, a 1M token window, listed 9 November 2026.
- Inkling 2 Small (Thinking Machines): $0.30 in and $1 out per million tokens, cached input $0.03, a 1M token window, listed 9 November 2026.
In this topic: AI models
- Gemini 4 Carbon vs Argon vs Hydrogen: Which to Use (2026)
- Gemini 4 Hydrogen: Benchmarks and Real Cost per Agent Task
- Best LLM for AI Agents: 20 Models Ranked (November 2026)
- Kimi K3.1 Pro: Benchmarks, Real Cost and Open Weights 2026
- Gemini 4 Argon vs Opus 5.5: Real Cost per Agent Task (2026)
- Muse Spark Open: Benchmarks, License, How to Run (2026)
- Gemini 4 Argon: Benchmarks, Real Cost and Access (2026)
- Meta Muse Wonder: Benchmarks, Pricing and Access (2026)