- Qwen3.8-Max is Alibaba’s new flagship model, made generally available on August 2, 2026. 2.4 trillion parameters, 95 billion active (MoE architecture).
- It reads text, images and video, and returns text. Context window is in the 1 million token class.
- On one task it ran 125 hours (about 5 days) with no human input, rebuilding an experiment from a machine learning paper from scratch, confirming its six findings, then inventing a method that beats the paper.
- It beats Claude Opus 4.8 on most coding and agent tests, trades blows with Claude Fable 5 and GPT-5.6 Sol, and falls behind on some.
- API pricing is $2 input / $6 output per million tokens. Repeated input costs $0.25.
- This is the first time Alibaba will open-weight a Max-class model. “Next week” is the word, but there is no date, license or model card yet.
Ask an AI to “rebuild the experiment in this paper, then improve on it” and it normally stalls after a few turns, waiting for you to step in and steer.
Qwen3.8-Max, which Alibaba released on August 2, 2026, did the job over 125 straight hours. Five days, no human intervention. All it had was the paper and a set of GPUs: no starter code, no ready-made pipeline. It wrote roughly 7,600 lines of code, took over 1,100 actions, ran 33 rounds of GPU training, and ended up with a method that beats the paper’s own.
The model was first shown as a preview on July 19 at the World AI Conference in Shanghai. It is now broadly available, with official scores and demo videos published. Let us look at what this 2.4 trillion parameter giant actually does. 👇🏻
What Is Qwen3.8-Max?
Qwen3.8-Max is the largest and most capable model in Alibaba Cloud’s Qwen family. It sits two generations past the Qwen3.5 series we reviewed in February.
What does it do? The same things ChatGPT or Claude do: you ask, it answers. It writes code, reads documents, analyses images. Three things set it apart:
- It accepts video as input. Alongside text and images, you can hand it video and get text back.
- It has a 1 million token class context window. Roughly 750,000 words, so several novels or an entire codebase in one go.
- It is built for long-horizon work. Alibaba’s whole pitch is tasks that run for days rather than turns.
What does 2.4 trillion parameters mean?
Think of parameters as the dials where a model stores what it has learned. 2.4 trillion is among the largest figures announced so far, a little under the 2.8 trillion of Kimi K3, which shipped in July.
The model uses a sparse mixture-of-experts (MoE) architecture. Not all 2.4 trillion parameters fire for every token, only 95 billion of them.
In an MoE model the total parameter count is the marketing figure. What determines serving cost, latency and whether you could ever run the thing yourself is how many parameters fire per token. For Qwen3.8-Max that is 95 billion, roughly 4% of the total.
Think of it as walking into a huge hospital where only the few doctors relevant to your problem attend to you. The building is enormous, your bill is not. That ratio is a large part of how Alibaba can price input at $2.
The real context window numbers
“1 million tokens” is the marketing headline. The actual API limits are slightly lower:
| Limit | Value |
|---|---|
| Max input | 991,000 tokens |
| Max input (with reasoning on) | 983,000 tokens |
| Max output | 131,000 tokens |
| Reasoning budget | up to 262,000 tokens |
Curious how many tokens your own text or code file works out to? Paste it into our token counter and you will see it instantly.
What Did It Actually Do? 🤯
Numbers are dull, the work is not. Here are the autonomous runs and videos Alibaba published, one by one.
16 days of software that evolved itself
The model was told to build a project called oh-my-cli, and then left alone. It set up a loop that runs on GitHub Issues: a requirement becomes an issue, an agent claims it, code gets written, tests and CI run, and the PR merges if they pass. Community feedback and its own test results feed back into the same loop.
As of July 30, 2026, after roughly 16 days of fully autonomous operation: 265 commits, 127 PRs, 151 issues. The full trace is public in the qwen-code-dev-bot/oh-my-cli repository.
125 hours to reproduce a paper, then beat it
The model was handed a recent paper, “Unified Data Selection for LLM Reasoning”, and asked to do two things: reproduce the experiment in code, then do better.
In the first 37 hours it rebuilt the entire pipeline from zero and reproduced the paper’s six main findings. Over the remaining 88 hours it ran a self-improving research loop, forming its own hypotheses and testing them: 18 improvement ideas across four rounds, each round’s results feeding the next. It finished with a new method that beats the paper’s own approach by 2.7 points on the AIME24 competition math benchmark.
👉🏻 You can browse the interactive trace of this run on Qwen’s site.
Beat 458 human teams in a 24-hour contest
The model was entered into a real competition on Alibaba Cloud’s Tianchi platform: the WWW2025 Multimodal Dialogue Intent Recognition Challenge, with 526 human teams competing. The task is to read customer service conversations, both text and screenshots, and work out what the customer wants.
Inside a strict 24-hour limit it read the rules and coded the whole solution. On the text side it fine-tuned and ensembled BERT, MacBERT and RoBERTa; for screenshots it fine-tuned Qwen2.5-VL-7B, falling back to a Chinese-CLIP model for images it was unsure about. Across 45 submissions its accuracy climbed from 0.60 to 0.853, beating 458 of the 526 human teams (87% of the field).
Real work across hundreds of professions
Alibaba stress-tested the model across several hundred high-value professions. A few:
- Corporate compliance counsel: surfaced 1,284 relevant clauses across hundreds of documents in a single pass, finishing the review in under an hour. That normally takes a paralegal team about a week.
- UI/UX designer: produced an interactive prototype for a digital banking app called NOVA, 8 screens with a consistent design system, in one shot with zero revision rounds.
- Restaurant founder: read over a hundred ingredient supply briefs and produced a complete 26-dish menu in one pass, each dish annotated with average calories and ingredient provenance, food cost ratio held at 33.8%.
- Structural engineer: from a single set of drawings, rebuilt the seismic model of a 30-storey office tower in the browser, with natural period, base shear and inter-storey drift readable on hover.
An end-to-end quant strategy in a single session
From a one-line task description it developed an ETF rotation strategy: built the data system, constructed base factors, analysed backtests and corrected course on its own. When it spotted an overfitting signal it pruned redundant factors; when several paths converged on the same signals it added multi-seed validation.
The breadth side is more striking. From six classic factor families (momentum, value, quality, investment, low-risk, sentiment) it decomposed each into 50 research directions, dispatched ~330 sub-agents and ran ~6,000 backtests. The selected factors achieved excess Sharpe ratios of 0.64 to 1.48.
500 turns that shrank a chip 12-fold
The model designed a GCD/RSA cryptographic hardware accelerator from scratch. It started with empty module templates and an evaluation script, no reference design, working in a sandbox wired to Iverilog (simulation), Yosys (synthesis) and OpenROAD (physical design).
In one continuous run it completed roughly 500 turns and 71 evaluations. Its first working design used 8,298 gates; it drove that down to 678. The single biggest step came at turn 22, when it replaced an expensive 16-bit hardware divider with an iterative shift-subtract architecture, cutting 6,288 gates in one move.
The physical layout followed: die area fell from 106x106 µm² to 46x46 µm² (an 81% reduction), wirelength from 33,369 µm to 4,187 µm, and the design achieved timing closure at 500 MHz. The notable part is that it was still making structural breakthroughs hundreds of turns in, where most models plateau after the early easy wins.
👉🏻 You can watch the design evolve turn by turn here.
Quadrupled its money in a 365-day e-commerce simulation
E-Commerce Bench is a year-long business simulation built on real, de-identified Taobao and Tmall transaction data: 12 store types, 60 product categories, nearly 600 suppliers, 7,000 products. The model gets ¥100,000 in starting capital and has to run several stores at once.
There are traps. Among the 600 suppliers, 152 fraudulent merchants are hidden, running classic scams (membership fee traps, low-price bait, goods not as described). On top of that come seasonal demand swings and random events like typhoons and material shortages.
Qwen3.8-Max ended the year with a balance of ¥416,252, a 4.16x return. That is 38% ahead of second-placed GLM 5.2 and 152% ahead of its own previous flagship, Qwen3.7-Max. The standout detail is that it kept driving supplier prices down across repeat negotiations with the same merchants, still learning after more than 2,000 rounds of interaction.
Vision inside the loop, not just at the door
On the multimodal side Alibaba’s emphasis is interesting: visual ability works not only on input but during execution.
It reads financial reports and complex PDFs beyond 200 pages, holding context across pages. On videos longer than 100 hours it does more than locate a moment; it organises people, events, timestamps and scenes into a “video memory graph”.
The real difference shows up while it works. The model watches and evaluates its own intermediate output. It inspects page layouts, object orientation, animation quality. When it notices a television facing the wrong way or a misaligned interface, it revises the plan and fixes the output itself. Vision becomes part of the plan-execute-verify-correct loop rather than just an input channel.
How Does It Compare? 📊
Alibaba did publish an official benchmark table this time. Its opponents are the four strongest models around: Claude Fable 5, Claude Opus 4.8, GPT-5.6 Sol and Gemini 3.1 Pro.
That chart is hard to read on a phone, so here are the lines that matter.
Where Qwen3.8-Max leads clearly:
- PaperBench (research reproduction): 93.0, ahead of both Fable 5 and GPT-5.6 Sol.
- TerminalBench-2.1 (terminal agent): 86.6, above both Claude models, just short of GPT-5.6 Sol at 88.8.
- OSWorld-Verified (agentic computer use): 86.1, the top score in the set.
- ERQA (embodied reasoning): 77.8 against a nearest rival at 70.0.
- PerceptionBench (visual perception): 63.5, a clear gap.
- LVBench (long video understanding): 81.8. On video it looks unmatched.
- Vision2Web (visual web development): 69.0.
- CoWorkBench (professional cowork tasks): 74.8, only behind Fable 5 at 75.9.
Where it falls behind:
- SWE-Pro (software engineering): 67.7. Fable 5 is far ahead at 80.0, and even Opus 4.8 (69.2) edges it out.
- FrontierSWE: 73.5 against Fable 5’s 88.8. Still a huge jump from its own predecessor Qwen3.7-Max at 40.7.
- JobBench (agents empowering human workflows): 53.4 against Fable 5’s 57.4.
- Agents’ Last Exam: 52.4 against GPT-5.6 Sol’s 53.6, a hair’s breadth.
- MobileWorld (agentic mobile use): 77.8 against Fable 5’s 85.5.
In short: Qwen3.8-Max is competing for the lead in research, terminal work, computer use and vision/video. On pure software engineering, Claude Fable 5 is still clearly ahead. The generational jump is steep though: FrontierSWE went from 40.7 to 73.5.
What Does It Cost, Is It Free? 💸
The easiest way to try it is Qwen Chat, which gives you limited free use.
To wire it into your own application, API pricing is as follows (per million tokens):
| Item | Price |
|---|---|
| Input (fresh content) | $2.00 |
| Input (repeated content) | $0.25 |
| Output (what the model writes) | $6.00 |
Two things worth noting:
There is no tiered pricing. Long prompts do not cost more per token. A giant 1 million token request bills at the same rate as a 2,000 token question. Some rivals double their rate past 200,000 tokens; this one does not.
Repeated content bills at one eighth. If you send the same long document or codebase on every request, you pay $0.25 instead of $2.00 from the second call onward.
For comparison: Kimi K3 charges $3 input and $15 output. The Claude and GPT flagships sit above that. Qwen3.8-Max is one of the cheaper options in this class.
What would that mean for your workload? Enter your input and output token counts in our LLM cost calculator and compare Qwen side by side with GPT and Claude.
Rate limits are generous too: 2 million tokens and 15,000 requests per minute.
For Developers: Getting Started in 5 Lines
The API is compatible with both the OpenAI and the Anthropic spec. You get your key from QwenCloud. Code you wrote for ChatGPT or Claude connects to Qwen3.8-Max with a two-line change:
from openai import OpenAI
import os
client = OpenAI(
api_key=os.environ.get("DASHSCOPE_API_KEY"),
base_url="https://dashscope-intl.aliyuncs.com/compatible-mode/v1", # the only difference
)
reply = client.chat.completions.create(
model="qwen3.8-max",
messages=[{"role": "user", "content": "Describe Qwen3.8-Max in one sentence."}],
extra_body={"enable_thinking": True},
reasoning_effort="xhigh", # xhigh, medium or low
stream=True,
)
Three things to know:
enable_thinkingturns on reasoning mode. With it on, maximum input drops from 991,000 to 983,000 tokens, because the reasoning steps consume context too.reasoning_efforttakes three levels:low,medium,xhigh. The default isxhigh, the slowest and most expensive one. Dropping it on simple tasks saves real money and latency.- The endpoint region is selectable. Beijing (
dashscope), Singapore (dashscope-intl) and US Virginia (dashscope-us). Pick whichever is closest to your users.
Using it with Claude Code
Because the Qwen API speaks the Anthropic protocol, you can point Claude Code straight at this model:
export ANTHROPIC_MODEL="qwen3.8-max"
export ANTHROPIC_SMALL_FAST_MODEL="qwen3.8-max"
export ANTHROPIC_BASE_URL=https://dashscope-intl.aliyuncs.com/apps/anthropic
export ANTHROPIC_AUTH_TOKEN=<your_api_key>
claude
Codex (via the OpenAI Responses protocol), Qoder CLI, Qwen Code and OpenClaw are supported the same way. Alibaba trained the model against all of these harnesses rather than binding it to one.
When Do the Weights Ship?
This is the most notable part of the announcement: Alibaba will open-weight a Max-class model for the first time. In the Qwen family open weights have so far been reserved for small and mid-size models, with the flagship staying closed.
The announcement said “next week”, but as of August 3, 2026 there is still no concrete date, license, model card or Hugging Face repository. So Qwen3.8-Max is currently a promised open-weight model.
There is also a practical question: what happens when it does ship? Storing the 2.4 trillion parameter model takes roughly 1.2 TB even at 4-bit precision, which rules out running it at home. The weights matter mainly for researchers, cloud providers and large teams running their own infrastructure.
Is There a Qwen3.8-27B? For Anyone Running It Locally
Short answer: no, no such model has been announced. Several tech outlets reported that a Qwen3.8-27B would go open-weight alongside the Max model, but it appears nowhere in Alibaba’s official announcement. The only thing promised is Max itself.
That said, the search is not misguided: the 27B line is real, just in the previous generation. Two models are downloadable today, both under Apache 2.0:
| Qwen3.6-27B | Qwen3.6-35B-A3B | |
|---|---|---|
| Architecture | Dense | Mixture-of-experts (MoE) |
| Total parameters | 27 billion | 35 billion |
| Firing per token | 27 billion (all of them) | 3 billion |
| Context | 262,144 tokens (~1M with YaRN) | 262,144 tokens (~1M with YaRN) |
| Input | Text + image | Text + image + video |
| License | Apache 2.0 | Apache 2.0 |
The counterintuitive part matters here: the 35B runs more comfortably on local hardware than the 27B, despite the larger name. Its MoE architecture fires only 3 billion parameters per token, while the dense 27B puts all 27 billion to work on every single token. Big label, small load.
How much VRAM do you need?
The rough maths is just parameter count times bytes per parameter. For the dense 27B:
| Quantisation | Approximate weight size |
|---|---|
| BF16 (unquantised) | ~54 GB |
| FP8 | ~27 GB |
| Q6 | ~22 GB |
| Q4 | ~15-16 GB |
Those are weights only. On top comes the KV cache for your context window, which grows fast at long context. If you intend to use the full 262K window, one card will not do it: Qwen’s own documentation suggests tensor parallel across 8 GPUs for best performance, and says to cut the context if you hit OOM, but to stay above 128K so reasoning quality holds.
In practice a single 24 GB card runs the Q4 quantisation of the 27B at a sensible context. For an easier start, take the 35B-A3B instead; with far fewer active parameters it is noticeably faster on the same hardware.
Ready-made quantisations exist: official FP8 files in Qwen’s own repository, community GGUF builds for Ollama and llama.cpp, and NVIDIA’s NVFP4 variants.
Kimi K3 vs Qwen3.8-Max
The two models launched three weeks apart and both come from China. A quick comparison:
| Kimi K3 | Qwen3.8-Max | |
|---|---|---|
| Company | Moonshot AI | Alibaba Cloud |
| Parameters | 2.8 trillion | 2.4 trillion |
| Active parameters | 16 of 896 experts | 95 billion |
| Video input | Yes | Yes |
| Input / output price | $3 / $15 | $2 / $6 |
| Weights | Released | Promised, no date |
| Strong at | Long-horizon software work | Research, terminal, vision |
We covered that model in detail in our Kimi K3 review.
Frequently Asked Questions
Q: When was Qwen3.8-Max released? A: Alibaba previewed it on July 19, 2026 at the World AI Conference in Shanghai and made it generally available on August 2, 2026.
Q: How many parameters does Qwen3.8-Max have? A: 2.4 trillion in total, of which 95 billion are active. It uses a sparse mixture-of-experts (MoE) architecture, so only about 4% of the parameters fire per token. That 95 billion figure is what actually drives cost and latency.
Q: Is Qwen3.8-Max free? A: You can try it with limits through Qwen Chat. Developer access is paid: $2 input and $6 output per million tokens.
Q: Is Qwen3.8-Max open source, can I download it? A: Not yet. Alibaba promised open weights “next week”, which would be the first time a Max-class Qwen model is opened. But no date, license or model card has been published. Technically it will be “open weight”: the model files ship, the training data does not.
Q: Is Qwen3.8-Max better than Claude or ChatGPT? A: It depends. On research reproduction (PaperBench), terminal agent work, computer use and video understanding it leads in the official scores. On pure software engineering (SWE-Pro, FrontierSWE) Claude Fable 5 is well ahead. All the scores are Alibaba’s own measurements.
Q: How large is the Qwen3.8-Max context window? A: It is in the 1 million token class. The real API limits are 991,000 tokens of input (983,000 with reasoning on) and 131,000 tokens of output.
Q: Does a Qwen3.8-27B exist? A: No, Alibaba has not announced one. Some outlets reported it, but it is absent from the official announcement. Qwen3.6-27B is real and downloadable today under Apache 2.0. For local use take that, or the lighter-running Qwen3.6-35B-A3B.
Q: How much VRAM does a Qwen 27B need? A: For weights alone, roughly 54 GB at BF16, 27 GB at FP8, and 15-16 GB at Q4. Add the KV cache for your context window on top. A single 24 GB card handles the Q4 build at a moderate context; long context needs multiple GPUs.
Q: Which is faster, the 27B or the 35B-A3B? A: Usually the 35B-A3B. Despite the larger name, its mixture-of-experts design fires only 3 billion parameters per token, whereas the dense 27B runs all 27 billion every time.
Q: Can I use Qwen3.8-Max with Claude Code? A: Yes. The Qwen API supports the Anthropic protocol. Set ANTHROPIC_BASE_URL to https://dashscope-intl.aliyuncs.com/apps/anthropic and ANTHROPIC_MODEL=qwen3.8-max, and Claude Code connects straight to it. Codex, Qoder CLI, Qwen Code and OpenClaw are supported too.
Stay well… 🙂