Qwen3.8-Max Explained: Alibaba's 2.4 Trillion Parameter Model and Its Open-Weight Promise

On August 3, 2026, Alibaba announced Qwen3.8-Max, calling it the most capable model in the Qwen family to date, and Alibaba's Hong Kong-listed shares jumped 7 percent to close at HK$125.20 the same day [1]. The model is a 2.4 trillion parameter mixture-of-experts design, it is already accessible through Alibaba Cloud's Model Studio API, and Alibaba framed it as a return to open-sourcing top-tier models after keeping its most recent flagship releases proprietary. There is one detail that got less attention than the headline number: as of a check three days later, no Qwen3.8-Max weights, no Qwen3.8-27B checkpoint, and no license file had actually appeared on Hugging Face's official Qwen organization page [2].

That gap between the announcement and the download is the real story worth understanding, alongside the architecture itself. This post walks through what Qwen3.8-Max actually is, how its mixture-of-experts design and its likely hybrid attention mechanism keep a 2.4 trillion parameter model usable, what the benchmark numbers say once you separate hosted-API claims from independently verifiable ones, and exactly where the open-weight release stands as of this writing.

If you would rather show this scale mechanism than describe it, here is a video generation prompt built around the same idea, written for a Wan-style video model:

A giant grain silo tilted at an angle pouring a thin steady stream of pastel colored grain into one small measuring cup on a long wooden table, the camera slowly pulling back to reveal dozens of identical empty measuring cups stretching off into the distance, soft warm studio lighting, clean scientific motion-graphics style, precise geometric shapes, no readable text, no logos, no people, smooth steady camera movement.

What Qwen3.8-Max Actually Is

Qwen3.8-Max is a sparse mixture-of-experts, or MoE, model with 2.4 trillion total parameters, of which only about 95 billion activate for any given token [3]. It reads a context window of up to 1 million tokens, roughly 750,000 words in a single request, and can produce up to 131,000 tokens of output in one response [4]. It is a native multimodal foundation model, accepting text, image, and video input, and Alibaba says it can process more than 200 pages of documents or roughly 100 hours of video in a single request, which is enough to reason over an entire television series or a long livestream in one pass [1].

Alibaba built Qwen3.8-Max on the foundation established by Qwen3.5, and it is positioned as the most powerful model in the Qwen series to date, with a specific emphasis on coding, real-world task automation, and long-horizon problem solving rather than pure knowledge recall [4]. That focus shows up directly in which benchmarks Alibaba chose to highlight, something we come back to below.

This is also not Qwen3.8-Max's first appearance on this blog. In our explainer on Kimi K3, we noted that Qwen3.8-Max arrived within weeks of Moonshot AI's own 2.8 trillion parameter open-weight release, and that the two launches together showed the open-weight frontier moving on a timescale of weeks rather than quarters. This post picks up where that one left off, going deep on Qwen3.8-Max specifically: its architecture, its benchmark story, and the open-weight timeline that is still playing out as you read this.

Step 1: Calling Qwen3.8-Max Yourself

Alibaba Cloud Model Studio exposes Qwen3.8-Max through both a DashScope-native API and an OpenAI-compatible endpoint, which means most existing chat or agent code only needs a base_url and model name change to point at Qwen3.8-Max instead of self-hosting anything [5]. The model is already live on Model Studio and on QwenWork, Alibaba's workplace AI agent platform, which entered public beta the same day as the model announcement.

python
/code
from openai import OpenAI

# Alibaba Cloud Model Studio exposes Qwen models through an OpenAI-compatible
# endpoint, so pointing an existing app at Qwen3.8-Max is a base_url and
# model-name change, not a rewrite of your request or response handling.
client = OpenAI(
    api_key="YOUR_DASHSCOPE_API_KEY",
    base_url="https://dashscope-intl.aliyuncs.com/compatible-mode/v1",
)

response = client.chat.completions.create(
    model="qwen3.8-max",
    messages=[
        {"role": "system", "content": "You are a concise technical writing assistant."},
        {
            "role": "user",
            "content": "Explain in three sentences why linear-scaling attention keeps a 1 million token context window usable, compared to standard quadratic attention.",
        },
    ],
    temperature=0.3,
)

print(response.choices[0].message.content)

Here is the same kind of request from the command line, using the REST endpoint directly, which is useful for a quick smoke test before wiring up an SDK:

bash
/code
# Same request as the Python example above, using the DashScope
# OpenAI-compatible REST endpoint directly. Useful for a quick smoke test
# before wiring up an SDK, or for shell-based tooling and CI checks.
curl https://dashscope-intl.aliyuncs.com/compatible-mode/v1/chat/completions \
  -H "Authorization: Bearer $DASHSCOPE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen3.8-max",
    "messages": [
      {"role": "user", "content": "Summarize the tradeoffs between hosted API access and self-hosting an open-weight model this large."}
    ]
  }'

Step 2: The Mixture-of-Experts Design, and Why It Keeps 2.4 Trillion Parameters Usable

The reason a 2.4 trillion parameter model is usable at all comes down to sparsity. A dense model of that size would need to run every parameter for every token, which is computationally absurd at this scale. Qwen3.8-Max instead splits its parameters into many smaller expert sub-networks and routes each token through only a handful of them, activating roughly 95 billion parameters per token out of the 2.4 trillion total [3]. Put another way, roughly 4 percent of the model's total weights do any work at all for a given token, and the router's job is deciding which 4 percent, potentially choosing an entirely different set of specialists for a line of Python versus a paragraph of conversational text.

This is the same broad approach Moonshot AI used in Kimi K3, and it is worth comparing the two side by side, since "total parameters" alone is a misleading way to judge which model actually costs more to serve. Qwen3.8-Max's 95 billion active parameters are noticeably leaner than Kimi K3's roughly 104 billion, even though Kimi K3's total parameter count is larger at 2.8 trillion. Active parameters per token, not the headline total, are what actually determine inference latency and GPU memory bandwidth pressure.

Step 3: The Hybrid Attention Mechanism Behind the 1 Million Token Context

Alibaba has not published a full architecture paper alongside the announcement, but independent technical coverage points to Qwen3.8-Max likely carrying forward the Gated DeltaNet-style hybrid attention mechanism introduced in Qwen3.5 and Qwen3.6, a linear-attention variant originally proposed by Nvidia researchers in 2024 [3]. That detail matters more than it might sound, because it is the mechanism that makes a genuinely usable 1 million token context window possible without the compute cost spiraling out of control.

Standard transformer attention is quadratic: every token has to compare itself against every other token in the context, so doubling the context length roughly quadruples the attention computation. A hybrid, linear-scaling design like Gated DeltaNet instead maintains a fixed-size recurrent state that gets updated as new tokens arrive, so the attention cost per token stays roughly constant regardless of how long the context grows, at the cost of some of the precise, full-history lookups that pure quadratic attention can do more exactly. Most hybrid designs, including the one Qwen3.5 and Qwen3.6 shipped, mix a small number of full quadratic-attention layers back in alongside the linear layers specifically to recover that precision where it matters most, which is why this class of architecture is called hybrid rather than purely linear. Here is a simplified illustration of just how different that growth curve looks in practice:

python
/code
# Toy comparison of how compute cost grows with context length under
# quadratic attention (the classic transformer default) versus a
# linear-scaling hybrid attention design like the one reportedly carried
# over from Qwen3.5 into Qwen3.8-Max. Numbers are relative units, not real
# FLOPs, just enough to show the shape of the curve.
context_lengths = [10_000, 100_000, 500_000, 1_000_000]

def quadratic_cost(tokens):
    return tokens ** 2

def linear_cost(tokens):
    return tokens * 50_000  # constant factor representing per-token overhead

for tokens in context_lengths:
    q = quadratic_cost(tokens)
    l = linear_cost(tokens)
    print(f"{tokens:>9,} tokens -> quadratic/linear ratio = {q / l:,.1f}x")

At 1 million tokens, that difference is not a rounding error. It is the difference between a context window that is technically supported on paper and one that is actually fast enough to use for a real 200-page document or a 100-hour video transcript, which is the specific capability Alibaba highlighted for this release [1].

Step 4: The Benchmark Numbers That Actually Matter

Benchmark claims are easy to make and hard to independently verify when they all come from a single hosted API, so it is worth being specific about what each number actually measures.

OSWorld-Verified evaluates a model's ability to operate a real desktop computer environment autonomously, clicking through applications, filling in forms, and completing multi-step tasks the way a human would, rather than answering a static question. Qwen3.8-Max scores 86.1 on this benchmark, ahead of GPT-5.6 Sol Max at 83.2, Claude Fable 5 at 85.0, and Gemini 3.1 Pro at 76.2 [4]. That is a genuinely different proposition than the usual open-weight release that trails the closed frontier by a generation, since this specific benchmark measures agentic computer-use skill rather than raw knowledge [4].

Qwen3.8-Max's PaperBench score of 93.0 is the highest reported for that evaluation, which tests a model's ability to read and reason over dense academic and technical documents [4]. On the Frontend Code Arena, a crowdsourced, head-to-head voting leaderboard where real users compare two anonymous rendered web apps and pick a winner, Qwen3.8-Max scored 1,668 points, trailing only Claude Opus 5's highest configuration by 37 points and ahead of more than a dozen other frontier models, including Meta's Muse Spark 1.1 [3]. Alibaba's own release materials also put Qwen3.8-Max fifth on Text Arena, second on Vision Arena, and fourth on Frontend Code Arena among all tracked models, not just the ones named above [6].

Alibaba also pointed to two demonstrated, hands-on capabilities rather than pure benchmark scores: the model completing a full 16-day coding project autonomously, and executing a chip design optimization task spanning more than 500 sequential steps without losing track of its own plan [3]. Those two case studies are a better signal of real long-horizon reliability than any single benchmark number, since they test whether a model can stay coherent across hundreds of decisions instead of answering one question in isolation.

A caveat worth stating plainly: every one of these numbers currently comes from Alibaba's own hosted infrastructure. Without the actual weights available to run independently, external researchers cannot reproduce these scores on their own hardware or their own held-out evaluation sets, which is exactly the gap the next section covers [2].

Case Study: What a 16-Day Autonomous Build and a 500-Step Task Actually Test

Leaderboard percentages compress an enormous amount of behavior into one number, and they hide what actually happens inside a single sustained task. Alibaba's two headline case studies for Qwen3.8-Max, the 16-day autonomous coding project and the chip design optimization spanning more than 500 sequential steps, are worth unpacking specifically because they test a different skill than any of the benchmarks above [3].

A single strong response to a single prompt does not require the model to remember what it decided ten steps ago, notice when an earlier assumption turned out to be wrong, or revise a plan without losing the parts of it that still hold up. A 16-day project does. Over that span, a coding agent has to track a growing codebase, remember which files it already touched and why, avoid re-solving problems it already solved, and recognize when a new piece of information, a failing test, an unexpected error, a changed requirement, means part of its earlier plan needs to change without throwing away the parts that are still correct. That is a fundamentally different failure mode than getting one answer wrong. A model can ace every individual benchmark question it is asked and still fail badly at a 16-day project if it cannot maintain a coherent internal state across hundreds of intermediate decisions.

The 500-step chip design optimization task tests a related but distinct capability: staying on a long, structured sequential process where each step depends on the outcome of the ones before it, closer to following a very long recipe than to open-ended exploration. Chip design optimization in particular tends to involve narrow, unforgiving correctness constraints, where a single misapplied step early in the sequence can invalidate everything that follows, which makes it a demanding test of whether a model's reasoning actually compounds correctly over a long horizon rather than drifting.

Neither case study is independently reproducible today for the same reason the benchmark scores above are not: both ran on Alibaba's own infrastructure, described in Alibaba's own release materials, without an external research team confirming the setup or the result on their own hardware [3]. That does not make the claims false, but it does mean the honest way to read them is as a strong signal of what Alibaba is optimizing Qwen3.8-Max for, long-horizon, multi-step, tool-using tasks rather than one-shot answers, not as a fully independently audited result.

Step 5: The Open-Weight Gap Nobody Should Skip Past

Multiple outlets described Qwen3.8-Max as "open-source" the day it launched. That framing runs ahead of what actually happened. Alibaba stated the weights for Qwen3.8-Max and a smaller Qwen3.8-27B variant would ship on Hugging Face and ModelScope the following week, meaning the week of August 10 [7]. When independent reporting checked the official Qwen organization page on Hugging Face on August 6, three days after the announcement, there was no Qwen3.8-Max repository, no Qwen3.8-27B checkpoint, and no license file to be found [2].

That report put the distinction bluntly: a commitment to publish weights is not published weights, and the word "open-source" had already been spent on the promise before a single tensor was downloadable [2]. It is a distinction worth internalizing any time a new model launch gets described as open-weight on day one: an API-accessible hosted service that anyone can rent on the vendor's terms is a fundamentally different thing than an open-weight model that anyone can download, audit, fine-tune, and run on their own hardware, independent of the original vendor staying online or friendly. Alibaba has also not disclosed the license Qwen3.8-Max will ship under, so it remains genuinely unclear whether it will land under something permissive like Apache 2.0, the same license Qwen's smaller models have used, or a more restrictive custom license with usage tiers, the way Kimi K3's revenue-triggered MIT-derived license works [8].

This is genuinely a first for Alibaba at this scale. Qwen3.8-Max is described as the first Qwen-Max-class model Alibaba has committed to open-sourcing at all, since prior Max-tier releases stayed proprietary and only the smaller Qwen model tiers shipped as open weights [4]. That makes the promise itself notable even before a single file lands on Hugging Face, but it also means there is no track record yet for how faithfully Alibaba follows through on a Max-class open-weight commitment specifically. If you are planning to build on the open weights rather than the hosted API, the practical move is to treat the promised week-of-August-10 date as a target to watch rather than a fact to build a roadmap around until the repository actually appears.

Step 6: QwenWork and the Agentic Workplace Race

QwenWork, which entered public beta alongside Qwen3.8-Max, is Alibaba's own workplace AI agent platform built on top of the model, aimed squarely at the same category as Anthropic's Claude Cowork, OpenAI's ChatGPT Work, Moonshot's Kimi Work, and Tencent's WorkBuddy [1]. That is a meaningfully different launch strategy than a pure API release. Alibaba is not just selling access to a strong general-purpose model, it is packaging Qwen3.8-Max into a specific agentic workplace product on day one, competing directly against both Western platforms and other Chinese labs racing on the exact same category.

It is worth separating Chinese AI labs by motive here, since they are not all playing the same game even when their models look similar on a spec sheet. DeepSeek and Moonshot behave like pure-play open-weight competitors, racing each other on weights, price, and release cadence. Alibaba, by contrast, is a platform giant that treats an open model release more like demand generation for a much larger cloud and workplace-software business, which is a different strategic bet, and QwenWork's simultaneous public beta launch is exactly the kind of monetization layer that strategy predicts.

The category itself, an AI agent that operates inside a company's actual workplace tools rather than a standalone chat window, is worth defining, since the name alone does not explain much. A workplace agent platform like QwenWork, Claude Cowork, or ChatGPT Work is built to read and write across the tools a team already uses, documents, spreadsheets, chat threads, tickets, calendars, rather than answering questions in isolation. That is precisely the kind of long-horizon, multi-step, tool-using workload the OSWorld-Verified benchmark and the 500-step chip design case study above are meant to stand in for. A model that is strong at agentic computer use on a benchmark is the same underlying capability a workplace platform needs to actually be useful day to day, which is why Alibaba is pairing this specific model with this specific product category on the same day rather than launching them separately.

Step 7: Pricing and the Hosted vs Self-Hosted Tradeoff

Qwen3.8-Max is priced at $2.00 per million input tokens and $6.00 per million output tokens through Alibaba Cloud Model Studio, with implicit prompt caching priced separately at $0.25 per million tokens [9]. That undercuts Kimi K3's $3.00 input and $15.00 output pricing by a wide margin, though DeepSeek V4 remains cheaper than both at $0.27 input and $0.87 output [10].

Here is a simple way to reason about what that pricing actually costs at real usage volumes, comparing the two most recent trillion-plus parameter open-weight-adjacent releases:

python
/code
# Rough monthly API cost comparison using published per-million-token
# pricing for the two most recent trillion-plus parameter open-weight
# releases. Implicit caching pricing is ignored here for simplicity.
MODELS = {
    "Qwen3.8-Max": {"input": 2.00, "output": 6.00},
    "Kimi K3": {"input": 3.00, "output": 15.00},
    "DeepSeek V4": {"input": 0.27, "output": 0.87},
}

def monthly_cost(model, input_tokens_millions, output_tokens_millions):
    rate = MODELS[model]
    return input_tokens_millions * rate["input"] + output_tokens_millions * rate["output"]

# Example: an agent pipeline reading 200M input tokens and writing 40M
# output tokens in a month.
for model in MODELS:
    cost = monthly_cost(model, 200, 40)
    print(f"{model}: ${cost:,.2f} per month")

Until the weights actually land, the hosted API is not really a choice, it is the only option, which makes this pricing table more relevant today than any self-hosting breakeven calculation. Once the open weights do ship, the same tradeoff that applies to Kimi K3 will apply here: self-hosting only makes economic sense once usage is high, sustained, and predictable enough to keep a GPU cluster's utilization consistently high, or when a data residency requirement rules out sending data to a third-party API entirely.

That walkthrough puts Qwen3.8-Max through real hands-on tests, including multimodal coding and interactive generation tasks, which is useful context alongside the benchmark numbers above.

Why This Matters Beyond the Leaderboard

Cheaper, more capable reasoning models change what is economically viable to build on top of, even for teams that never touch a Chinese cloud provider directly. A pipeline like Text2Shorts in Miraflow AI, which turns a topic into a script, then scene visuals, then a finished short, depends on a language model reasoning well and cheaply at every one of those steps, thousands of times a day. The same is true of AI Clipping, where a model has to transcribe a long video, judge which moments are actually engaging, and score them before a single clip gets cut, a task that benefits directly from the kind of long-context, agentic reliability Qwen3.8-Max's OSWorld-Verified score is measuring. As open-weight and hosted models keep pushing this kind of reasoning cost down, the economics of running a multi-step creative pipeline at scale keep improving, which is a big part of why releases like this are worth tracking even if you never call the API yourself.

Common Mistakes When Evaluating a Release Like This

A few misunderstandings come up constantly when people react to a launch like Qwen3.8-Max's.

• Calling a model "open-source" the moment it is announced, when only a promise to publish weights exists, not an actual downloadable repository. Check the license and the model page directly before repeating that label.
• Assuming a benchmark win on one leaderboard means the model is better for your specific task. OSWorld-Verified, PaperBench, and Frontend Code Arena measure genuinely different skills, and a model that leads one can trail on another for the same underlying reason it leads the first.
• Comparing total parameter counts without checking active parameters per token. Qwen3.8-Max's 2.4 trillion total is smaller than Kimi K3's 2.8 trillion, but its active parameter count is also smaller, which is the number that actually predicts serving cost.
• Treating every benchmark number as independently verified. Until the weights ship, every published score comes from the vendor's own hosted infrastructure, which is a real limitation worth naming rather than ignoring.
• Assuming "hybrid attention" architecture claims are officially confirmed. Alibaba has not published a full architecture paper for this release, and the Gated DeltaNet-style design is a well-sourced inference from Qwen3.5 and Qwen3.6's known architecture, not a confirmed detail from Alibaba itself.
• Ignoring the license question entirely. "Open weight" and "free to use however you want" are not the same thing, and Qwen3.8-Max's license terms remain undisclosed as of this writing.

Running Qwen3.8-Max in Production: What to Actually Watch

If you are evaluating Qwen3.8-Max today, the hosted API through Model Studio is the only realistic path, and that is not a bad starting point given the pricing sits well below Kimi K3's on both input and output tokens. Benchmark the model against your own workload rather than trusting a general leaderboard number, since OSWorld-style agentic performance and long-context document reasoning do not necessarily predict how well a model handles your specific tool-calling setup or prompt style.

If your application makes repeated calls with a long, mostly unchanged system prompt or document context, structure your requests to take advantage of the $0.25 per million token implicit caching rate, since that discount compounds quickly across a high-volume pipeline that reuses the same context window across many calls. If you are specifically waiting on the open-weight release to self-host, treat the week-of-August-10 date as a target to monitor on the official Qwen Hugging Face organization page rather than a commitment to plan a production migration around, given the gap already observed between the announcement and the download. And once the weights and license do land, read the license text itself before assuming it matches the permissive terms of Qwen's smaller models, since a Max-class release is exactly the kind of high-value model a vendor might choose to gate more carefully than a smaller one.

Frequently Asked Questions

Is Qwen3.8-Max open source right now? Not yet in the sense of downloadable weights. Alibaba announced it on August 3, 2026 with a promise to publish the weights the following week, but as of an independent check on August 6, no Qwen3.8-Max repository or license had appeared on Hugging Face. Today it is only accessible as a hosted API.

How does Qwen3.8-Max compare to Kimi K3? Both are trillion-plus parameter mixture-of-experts models released within weeks of each other. Kimi K3 is larger at 2.8 trillion total parameters versus Qwen3.8-Max's 2.4 trillion, but Qwen3.8-Max activates fewer parameters per token and is priced lower on both input and output tokens.

Do I need a GPU cluster to try Qwen3.8-Max? No. Alibaba Cloud Model Studio provides hosted access through both a DashScope-native API and an OpenAI-compatible endpoint, which is how virtually everyone will use the model until the open weights, if and when they ship, become available to self-host.

What does the hybrid attention design actually save you? Compute cost as context grows. Standard quadratic attention gets dramatically more expensive as the context window grows longer, while a linear-scaling hybrid design keeps the per-token attention cost roughly constant, which is what makes a genuinely usable 1 million token context window realistic rather than theoretical.

Why does OSWorld-Verified matter more than a general knowledge benchmark here? OSWorld-Verified tests whether a model can actually operate a computer autonomously across a multi-step task, which is a closer proxy for real agentic and workplace usage than a static question-and-answer benchmark, and it is the specific benchmark where Qwen3.8-Max currently leads named competitors including GPT-5.6 Sol Max and Gemini 3.1 Pro.

Is Qwen3.8-Max better than Claude Fable 5 or GPT-5.6 Sol Max? On OSWorld-Verified specifically, Qwen3.8-Max's 86.1 score is ahead of both. On the Frontend Code Arena, it trails Claude Opus 5's highest configuration by 37 points. Which model is "better" depends heavily on which specific task and benchmark you weight most, and none of these scores are yet independently reproducible outside the vendors' own hosted infrastructure.

Conclusion

Qwen3.8-Max is a genuinely significant release on its technical merits: a 2.4 trillion parameter mixture-of-experts model with a likely linear-scaling hybrid attention design, a real 1 million token context window, and benchmark numbers that lead named frontier competitors on agentic computer-use tasks specifically. What makes it worth tracking closely rather than taking at face value is the gap between what got announced and what has actually shipped so far. The open-weight promise is real, the pricing already available today is genuinely competitive, and the QwenWork launch shows Alibaba is playing a platform game, not just a leaderboard game. Whether the weights actually land on Hugging Face the week of August 10 as promised, and under what license, is the detail that turns this from a strong hosted API into the open-weight event Alibaba is currently getting credit for. For more on how mixture-of-experts architecture makes models like this economically viable at all, our explainer on Kimi K3 covers the routing mechanism in more depth, and our look at speculative decoding covers the other major lever, inference speed, that determines whether a model like this actually feels fast to use in production.

References and Sources

[1] South China Morning Post. "Alibaba's AI model Qwen3.8-Max made widely accessible ahead of open-weights release."

[2] Cherry Creek News. "Alibaba's New AI Was Called Open-Source. Its Model Page Is Empty."

[3] SiliconANGLE. "Alibaba debuts Qwen3.8-Max model with 2.4T parameters."

[4] DataCamp. "Qwen3.8-Max: Features, Benchmarks, and Pricing."

[5] Alibaba Cloud Documentation Center. "Call Qwen models via OpenAI API."

[6] Alibaba Group. "Alibaba Unveils Qwen3.8-Max: Its Largest and Most Capable Flagship Model to Date."

[7] MarkTechPost. "Alibaba Qwen Releases Qwen3.8-Max: A 2.4 Trillion Parameter MoE Model."

[8] Digital Applied. "Qwen3.8 Open Weights: Check This Before Downloading."

[9] Forbes. "Alibaba's Qwen3.8-Max Prices Frontier AI At $2 Per Million Tokens."

[10] Miraflow AI. "DeepSeek V4 Explained: The Open-Source AI That Rivals GPT-5.5 at 1/7th the Price."