Alibaba's Qwen3.8-Max is now generally available as of August 3, 2026 — and for the first time in the Qwen family's history, a Max-class (frontier-tier) model is shipping with open weights. The 2.4-trillion-parameter Mixture-of-Experts model激活 only 95 billion parameters per forward pass, giving you frontier-scale knowledge capacity without frontier-scale inference cost per token.
The open weights for Qwen3.8-Max are scheduled to drop the week of August 10, 2026, on Hugging Face and ModelScope. A companion dense model, Qwen3.8-27B, designed for local enterprise servers, goes open-weight the same week. This is the story of what the model actually does, how it benchmarks against Claude Fable 5 and Kimi K3, and whether you should care.
What Qwen3.8-Max Actually Is
Qwen3.8-Max is built on the architecture of Qwen 3.5, carrying forward the hybrid attention design that distinguished that generation. The headline specifications:
- 2.4 trillion total parameters with 95 billion active per token (MoE)
- 1 million token context window natively supported
- 131,072 token maximum output
- Multimodal: text, image, and video input; text output
- Always-on reasoning with low, medium, and xhigh effort levels (xhigh is default)
- API pricing: $2 per million input tokens, $6 per million output tokens
- Model ID:
qwen3.8-maxon QwenCloud / DashScope
The reasoning is always enabled — there's no separate "thinking" variant. You control how much the model reasons via the effort setting, from low (fast, cheap) to xhigh (deep, slower). The preserve_thinking flag is enabled by default, meaning the model's chain-of-thought is preserved across tool calls within a session.
The Autonomous Coding Run: 16 Days, Zero Human Help
The most striking launch artifact isn't a benchmark number — it's a GitHub repository. Qwen3.8-Max built oh-my-cli from an empty project and ran autonomously for approximately 16 days straight. As of July 30, 2026, the repo showed 265 commits, 127 pull requests, and 151 issues — all filed and resolved by the model itself.
The system works through what Qwen calls a "self-evolving harness." The model didn't just write code; it built its own issue tracker, dispatch system, and CI pipeline:
- Issue state machine: Requirements are normalized into GitHub issues, each moving through
ready → leased → active → mergedstates. - Dispatcher: Sub-agents claim issues, write code, and open PRs.
- Monitor: Automated tests run end-to-end, unit, and desktop-lifecycle checks.
- Watchdog: Failures route back into new issues, creating a closed feedback loop.
The repository is fully public. You can inspect every commit, every failed test, every recovery attempt. This is the most inspectable launch artifact because the entire history is there — not just a final screenshot.
The Research Paper Reproduction
In a second long-horizon test, Qwen gave the model the paper "Unified Data Selection for LLM Reasoning" (arXiv: 2605.22389) and GPU access — no starter code. Over roughly 125 hours (~5 days), the model:
- Wrote about 7,600 lines of code
- Took more than 1,100 actions
- Ran 33 GPU training rounds
- Reproduced all 6 main findings in ~37 hours (the paper's method beat random selection by +7.7% on AIME24)
- Then ran a self-improving loop for ~88 hours, testing 18 ideas across 4 rounds
- Final method ("nhighgate") beat the paper's approach by +2.71 points on AIME24
This is the pattern that matters: the model improves because the environment tells it what failed. It's not a one-shot chatbot — it's a feedback-loop agent.
The Kaggle Competition
In a third case, Qwen3.8-Max entered the WWW2025 Multimodal Dialogue Intent Recognition Challenge, where 526 human teams were competing. The model built a solution in 24 hours using ensembled BERT, MacBERT, and RoBERTa for text, plus Qwen2.5-VL-7B and Chinese-CLIP for images. Across 45 submissions, accuracy climbed from 0.60 to 0.853, beating 458 of 526 human teams — 87% of the field.
How Qwen3.8-Max Benchmarks Against the Competition
Alibaba claims Qwen3.8-Max is "second only to Claude Fable 5" globally. Based on the official benchmark table published August 3, here's how it stacks up:
| Benchmark | Qwen3.8-Max | Claude Fable 5 | Kimi K3 | DeepSeek V4 Flash |
|---|---|---|---|---|
| PaperBench | Leading | Strong | — | — |
| Terminal-Bench 2.0 | Strong | Strong | — | — |
| SWE-bench Pro | Strong | Leading | — | — |
| FrontierSWE | Strong | Leading | — | — |
| Visual reasoning | Leading | Strong | — | — |
| Long-video understanding | Leading | — | — | — |
| Computer use | Leading | Strong | — | — |
| Frontend Code Arena | — | — | #1 | — |
Important caveats: these are vendor-reported numbers using different harnesses, context limits, timeouts, and tool access configurations. Some results used Claude Code, some used Codex, some used specialized setups. The chart is a useful map of capability, not a controlled price-performance comparison.
What's clear: Qwen3.8-Max leads on PaperBench, visual reasoning, long-video understanding, and computer-use benchmarks. Claude Fable 5 still leads on SWE-bench Pro and FrontierSWE. GPT-5.6 Sol leads Terminal-Bench. No single model wins everything.
Professional Work: What It Can Actually Do for Your Business
Beyond coding benchmarks, Qwen demonstrated Qwen3.8-Max across six high-value professional domains — each with a concrete before/after comparison:
Legal compliance: Surfaced 1,284 clauses across hundreds of documents in under an hour. A paralegal team typically takes a week for equivalent work.
UI/UX design: Delivered an 8-screen interactive prototype in a single pass with zero revision rounds. Designers typically need 3-5 rounds.
Restaurant branding: Produced a 26-dish menu with calorie counts and ingredient provenance from 100+ briefs, holding food-cost ratio at 33.8%.
Structural engineering: Reconstructed a 30-story seismic structural model in a browser from drawings — work that typically takes a week.
Healthcare: Converted a 2D assessment form into a 3D interactive demo with anatomical overlays — typically 2-4 weeks and thousands of dollars.
Sports analytics: Parsed approximately 8,400 possessions into a tactical profile in tens of minutes instead of days.
End-to-End Quant Strategy
In a deeper demonstration, the model built an ETF-rotation strategy from a one-line description. It autonomously planned the workflow, ran multi-round greedy iteration, auto-pruned redundant factors, and dispatched ~330 sub-agents that completed ~6,000 backtests. Results: excess Sharpe ratios of 0.64-1.48, IC uniformly positive (0.010-0.014). Weeks of quant researcher work, compressed into a single conversation.
API Access and Pricing: How to Get Started
Qwen3.8-Max is available through several channels:
QwenCloud API (primary): The model ID is qwen3.8-max. Pricing is $2 per million input tokens and $6 per million output tokens — roughly 5x cheaper than Claude Fable 5 ($10/$50) and 2.5x cheaper than Kimi K3 ($3/$15).
Third-party providers: Available on OpenRouter, Qubrid AI, and other hosted inference platforms. Some list pricing as low as $2.30/M input.
Agent tool integration: Qwen Cloud documents connections to Qwen Code, Codex, Claude Code, Cursor, OpenCode, Cline, and OpenClaw. The model works as a drop-in replacement in most OpenAI-compatible agent frameworks.
Token Plan subscriptions (for interactive/preview use): Lite at $6/month, Standard at $18/month, Pro at $68/month. These are credit-based and restricted to interactive use inside compatible tools — not for automated backend scripts.
Here's a minimal Python call using the DashScope SDK:
import os
import dashscope
dashscope.base_http_api_url = "https://dashscope-intl.aliyuncs.com/api/v1"
response = dashscope.Generation.call(
api_key=os.getenv('DASHSCOPE_API_KEY'),
model='qwen3.8-max',
messages=[{"role": "user", "content": "Write a Python CLI that watches a directory and logs file changes."}],
)
print(response.output.choices[0].message.content)
For multimodal input (text + image):
messages = [{
"role": "user",
"content": [
{"image": "https://example.com/diagram.png"},
{"text": "Explain this architecture diagram and suggest improvements."}
]
}]
response = dashscope.MultiModalConversation.call(
api_key=os.getenv('DASHSCOPE_API_KEY'),
model='qwen3.8-max',
messages=messages
)
Qwen3.8-Max vs Kimi K3: Which Should You Use?
Both models launched within weeks of each other, both are Chinese open-weight flagships, and both compete directly with Western frontier models. Here's the practical comparison:
| Dimension | Qwen3.8-Max | Kimi K3 |
|---|---|---|
| Total parameters | 2.4T | 2.8T |
| Active parameters | 95B | 50B (16 of 896 experts) |
| Context window | 1M tokens | 1M tokens |
| API price (input/output per 1M) | $2 / $6 | $3 / $15 |
| Open weights | Week of Aug 10, 2026 | Released July 26, 2026 |
| Architecture | MoE (Qwen 3.5 base) | MoE (LatentMoE + KDA) |
| Multimodal | Text + image + video | Text + image |
| Reasoning | Always on (xhigh default) | Always on ("thinking mode") |
| Strongest signal | Autonomous coding runs | Frontend Code Arena #1 |
| License | TBA | Modified MIT |
If you need open weights now: Kimi K3's weights landed July 26 (1.56 TB download, 118 files). Qwen3.8-Max weights are promised for the week of August 10 but not yet available.
If you're choosing by API cost: Qwen3.8-Max at $2/$6 is significantly cheaper than Kimi K3 at $3/$15 per million tokens. For high-volume agent workflows, that 2.5x output cost difference adds up fast.
If you want video understanding: Qwen3.8-Max supports video input natively. Kimi K3 does not — it's text and image only.
If you're doing frontend coding: Kimi K3 holds the #1 spot on the Frontend Code Arena. Qwen3.8-Max leads on PaperBench and computer-use tasks but hasn't claimed that specific benchmark.
For a deeper dive on Kimi K3 setup with agent frameworks, see our Kimi K3 agent setup guide.
The Open Weights Question: What You Can Actually Run
This is the part most coverage skips. A 2.4-trillion-parameter model is a datacenter object, not a laptop model — no matter how aggressively you quantize it. The MoE architecture means only 95 billion parameters activate per forward pass, which helps inference speed, but the full checkpoint still needs to reside in memory.
Based on Qwen's own track record, here's what the open-weight timeline typically looks like:
- Qwen 3.5 (Feb 2026): Flagship 397B on day one; runnable 27B dense and 35B-A3B MoE within 8-11 days; 9B (fits 8GB GPU) within 11 days
- Qwen 3.6 (Apr 2026): Open weights arrived alongside the paid tier — no wait at all
- Qwen 3.7 (May 2026): Closed API only, no open weights ever followed — the pattern broke
Qwen3.8-Max returns to the open-weight path, and the concurrent Qwen3.8-27B announcement suggests Alibaba is shipping a runnable companion alongside the flagship. If history repeats, expect a 9B or smaller variant within two weeks of the flagship drop.
For self-hosting context: even with MXFP4 quantization, the full 2.4T checkpoint will require significant GPU resources — likely 8x H100 80GB minimum, similar to Kimi K3's requirements. The 27B dense model is the one that fits on a single consumer GPU and is the practical pick for most teams.
For guidance on running open-weight models locally — including hardware tiers and alternative smaller models that fit consumer GPUs today — check our budget AI model decision guide.
What the Launch Does NOT Prove
Qwen's own marketing materials, and the independent analysis by JQ AI Systems, flag several important limitations:
Vendor benchmarks are not independent verification. The benchmark chart uses different harnesses, context limits, tools, timeouts, and scoring methods across models. It's a capability map, not a controlled experiment.
Autonomous duration is not autonomous quality. A 16-day coding run can produce valuable work or compound unnoticed mistakes. The right follow-up is to audit merged changes, failure recovery, human intervention logs, and test strength — not just count commits.
Professional demos are not deployment studies. Legal, finance, healthcare, and engineering outputs still need domain-specific controls, compliance review, and accountable human oversight before production use.
API cost is incomplete. Token pricing doesn't include harness compute, GPU experiments for self-hosting, storage, human review time, and failed runs. Total cost of ownership is always higher than the per-token rate.
Open weights don't make Max a laptop model. MoE lowers active compute, but the full 2.4T checkpoint is enormous to store and serve. The 27B companion is the practical self-hosting option.
"Second only to Fable 5" is a positioning claim, not a verified ranking. As of the initial July 19 preview, Alibaba had not published the supporting benchmark table. The August 3 GA release included a fuller benchmark picture, but methodology notes show varying harness configurations across results.
A Practical 7-Day Evaluation Plan
If you're considering Qwen3.8-Max for production, don't trust vendor benchmarks — run your own:
Day 1 — Define success. Pick one real task with a clear pass condition: a repo issue, a browser workflow, a data extraction task.
Day 2 — Freeze the harness. Record the tool version, system prompt, permissions, repo commit, machine, region, and model settings. Pin everything.
Day 3 — Write the verifier first. Add tests, browser assertions, source checks, image comparisons, or a structured review rubric. The verifier must be independent of the model.
Day 4 — Compare reasoning levels. Run the same task at low, medium, and xhigh with the same budget and retry policy. Measure quality vs. latency vs. cost.
Day 5 — Inject failure. Break an assumption, expire a credential, remove a file, or return a malformed tool response. Measure how the model recovers. This is where feedback-loop agents should shine.
Day 6 — Compare one alternative. Run the same harness and acceptance checks with your current model — Claude Fable 5, GPT-5.6 Sol, DeepSeek V4 Flash, or Kimi K3.
Day 7 — Decide with economics. Calculate accepted outputs per dollar, wall-clock time, review minutes needed, regressions found, and security exceptions. The cheapest model per token is not always the cheapest model per good outcome.
One critical reminder: as model capabilities evolve rapidly, old agent setups can actively hurt new models. See our guide on agent setup decay — the prompt scaffolding and tool configurations that helped older models may constrain Qwen3.8-Max's autonomous capabilities.
The Bottom Line
Qwen3.8-Max is most interesting as a feedback-loop model, not a one-shot chatbot. Test it on work that has an objective verifier — tests, backtests, rendered-output checks, structured rubrics, or a human approval gate. The launch evidence repeatedly shows the model improving because the environment tells it what failed.
At $2/$6 per million tokens with open weights coming, it's the cheapest frontier-tier API available right now, and the autonomous coding demonstrations — while first-party and vendor-curated — represent the most inspectable agentic capability evidence any lab has published. The oh-my-cli repository is public. You can audit every commit.
The question isn't whether Qwen3.8-Max beats Claude Fable 5 on every benchmark (it doesn't). The question is whether a feedback-loop agent at one-fifth the cost, with open weights arriving next week, fits your workflow. For long-horizon coding tasks with automated verification, it's worth a serious evaluation. For one-shot reasoning, Fable 5 and GPT-5.6 Sol still hold their ground.
Frequently Asked Questions
What is Qwen3.8-Max?
Qwen3.8-Max is Alibaba's flagship AI model with 2.4 trillion total parameters (95 billion active per token via Mixture-of-Experts architecture). It launched August 3, 2026, with open weights scheduled for the week of August 10. It supports text, image, and video input with a 1-million-token context window.
How much does Qwen3.8-Max cost?
Qwen3.8-Max API pricing is $2 per million input tokens and $6 per million output tokens via QwenCloud/DashScope. This makes it roughly 5x cheaper than Claude Fable 5 ($10/$50) and 2.5x cheaper than Kimi K3 ($3/$15).
Can I run Qwen3.8-Max locally?
The full 2.4T-parameter model requires datacenter-class hardware (estimated 8x H100 80GB minimum even quantized). However, the companion Qwen3.8-27B dense model — designed for local enterprise servers — goes open-weight the same week and should run on a single GPU.
How does Qwen3.8-Max compare to Kimi K3?
Qwen3.8-Max has 2.4T parameters vs Kimi K3's 2.8T, but Qwen is cheaper ($2/$6 vs $3/$15), supports video input (Kimi K3 doesn't), and leads on PaperBench and computer-use benchmarks. Kimi K3 holds #1 on Frontend Code Arena. Kimi K3's open weights are already available; Qwen3.8-Max weights arrive the week of August 10.
Is Qwen3.8-Max really second only to Claude Fable 5?
Alibaba claims Qwen3.8-Max ranks second globally behind Claude Fable 5. The published benchmark chart supports this on PaperBench, visual reasoning, and computer-use tasks. However, Fable 5 still leads on SWE-bench Pro and FrontierSWE, and the results use different harnesses and configurations — treat the ranking as a capability map, not a controlled comparison.
What's the difference between Qwen3.8-Max and Qwen3.8-27B?
Qwen3.8-Max is the 2.4T MoE flagship for datacenter deployment. Qwen3.8-27B is a 27-billion-parameter dense model designed for local enterprise servers without requiring massive GPU clusters. Both go open-weight the week of August 10, 2026.
Discussion
0 comments