Qwen3.8 Max vs GPT-5.6 Sol & Kimi K3: Full Comparison

For two weeks, Alibaba's newest flagship had no benchmark table. Just a parameter count and a claim: "second only to Claude Fable 5."

Qwen 3.8 Max was previewed on July 19, 2026, at the World AI Conference in Shanghai as a preview endpoint. No scores shipped with the announcement. Every early writeup ran on vibes and vendor promises. Then August 3 arrived.

Alibaba published a full benchmark table with the official release. The numbers showed genuine strengths across terminal agents, multimodal work, and instruction following, alongside real weaknesses on the hardest software engineering benchmarks. This is what that table actually means for teams deciding whether to switch.

What Qwen3.8 Max Actually Is

Qwen3.8-Max was officially announced on August 3, 2026. The hosted model became available through Qwen Studio and QwenCloud at launch, with open weights announced but not yet published.

It carries 2.4 trillion total parameters in a sparse Mixture-of-Experts architecture, with roughly 95 billion parameters active per token. The active parameter count is what drives serving cost. You pay for 95B compute, not 2.4T.

Qwen says Qwen3.8 Max builds on the Qwen3.5 architecture and scales to 2.4T total parameters. Qwen calls it the first Max-class open-weight model, but the tense matters. The release article says the weights arrive the following week on Hugging Face and ModelScope.

Official Qwen Cloud integration metadata lists a 983,616-token context window and 131,072-token maximum output. Thinking is always enabled, with low, medium, and xhigh reasoning settings.

 Qwen3.8 Max architecture overview

Architecture: How a 2.4T Model Runs on Practical Hardware

Qwen3.8 Max uses the same sparse MoE design philosophy that defines the entire 2026 open-weight frontier. Most parameters stay idle. Only a small fraction activates per token.

The sparse Mixture-of-Experts architecture activates roughly 95 billion parameters per token. Active parameters are the number that drives serving cost. A 2.4T total model running at 95B active per token costs roughly the same to serve as a dense 100B model. The knowledge base is 2.4T deep. The compute bill reflects 95B.

The context window sits at approximately one million tokens with up to 128,000 output tokens per call. Thinking is always enabled at launch, with low, medium, and xhigh reasoning effort selectable per request. The xhigh setting is the documented default for the preview.

Multimodal input is confirmed at launch. Text plus visual inputs are confirmed. Coverage differs on the full list; video, documents, speech, and image generation have all been reported. Alibaba has not published a full spec sheet for modality support.

The model supports OpenAI-compatible and Anthropic-compatible API specifications, making migration from existing infrastructure straightforward for most teams.

  Model performance

The Benchmark Table: What Is Verified and What Is Not

This is where most coverage of Qwen3.8 Max gets sloppy. Alibaba published scores. Those scores come from Alibaba's own evaluation runs, not independent third-party replication. The distinction matters.

Here is what the official table shows, labeled accurately:

Coding and Agent Benchmarks (Alibaba-run):

Qwen3.8-Max scores 86.6 on Terminal-Bench 2.1, 67.7 on SWE-bench Pro, 56.6 on DeepSWE 1.1, and 93.0 on PaperBench. IFBench lands at 82.8.

Additional coding results include 74.8 on CoWorkBench and 81.9 on WideSearch, alongside 92.6 on GPQA Diamond and 92.9 on MRCR v2 at 256K.

Multimodal Benchmarks (Alibaba-run):

Multimodal results include 82.3 on MMMU-Pro, 86.1 on OSWorld-Verified, 92.1 on OmniDocBench 1.5, and 90.4 on Video-MME with subtitles.

The only independent data point available at launch:

An independent evaluator ran Qwen 3.8-Max preview and Kimi K3 through a production-style software architecture task, analyzing 269 files across two real projects and proposing system designs, blind-reviewed and fact-checked. Result: Kimi K3 scored 83 out of 100, Qwen 3.8-Max preview scored 80. Notable: none of Qwen's 44 tool calls failed, a strong signal for agent reliability.

That is one test, one workload type. But it is a real one, not a preference vote.

Where Qwen3.8 Max Wins and Where It Does Not

Reading the benchmark table carefully reveals a model with specific strengths, not a universal crown.

Strong results:

On Terminal-Bench 2.1, Qwen 3.8-Max scores 86.6 against 84.6 for both Claude Opus 4.8 and Claude Fable 5. GPT-5.6 Sol leads the row at 88.8, so this is a second-place finish. Beating both Anthropic flagships on an agentic terminal benchmark is the headline result Alibaba wanted from this launch.

OSWorld-Verified lands at 86.1, above both Claude Fable 5 at roughly 85.0 and GPT-5.6 Sol at 83.2 on desktop OS interaction tasks.

PaperBench reaches 93.0, the highest reported score on scientific paper analysis, ahead of GPT-5.6 Sol at 90.5 and Claude Fable 5 at 88.8.

On IFBench, Qwen 3.8-Max posts 82.8. The nearest non-Qwen competitor in the table is GPT-5.6 Sol at 72.7, with Fable 5 at 63.5 and Opus 4.8 at 62.2. That is a 10 to 20 point gap, which is unusual on a benchmark this saturated. Instruction following looks like a durable Qwen strength across model generations.

Where it trails:

On SWE-bench Pro, Qwen3.8-Max lands at 67.7 against Fable 5's 80.0 and Opus 4.8's 69.2. It scores 73.5 on FrontierSWE against Fable 5's 88.8.

On the hardest software engineering tasks, Qwen3.8 Max sits mid-pack. It is ahead of GPT-5.6 Sol on SWE-bench Pro at 64.6, but a full 12 points behind Fable 5.

The pattern is clear. Qwen3.8 Max dominates terminal agents, document intelligence, instruction following, and computer use. It is not yet the top choice for pure SWE-level software engineering that requires the deepest code reasoning.

Pricing: Clear and Straightforward

The standard API is $2 per million input tokens, $6 per million output tokens, and $0.25 for cached input. The Token Plan subscription is the alternative for individual use.

This positions Qwen3.8 Max between Sonnet-class and Opus-class pricing from Anthropic. The implicit caching at $0.25 per million input tokens makes long-context agentic work meaningfully cheaper for workloads where the same large prompt gets reused across many calls.

  Pricing comparison

How to Use Qwen3.8 Max via API

Qwen3.8-Max is OpenAI-spec compatible. Set the base URL and drop it into any existing client:

from openai import OpenAI
import os

client = OpenAI(
    api_key=os.environ["QWEN_API_KEY"],
    base_url="https://api.qwencloud.ai/v1",
)

response = client.chat.completions.create(
    model="qwen3.8-max",
    messages=[
        {
            "role": "user",
            "content": "Analyze this codebase and identify the three highest-risk components."
        }
    ],
    extra_body={"reasoning_effort": "xhigh"},
)
print(response.choices[0].message.content)

With vision input:

import base64
from pathlib import Path

image_data = base64.b64encode(Path("screenshot.png").read_bytes()).decode()

response = client.chat.completions.create(
    model="qwen3.8-max",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "image_url",
                    "image_url": {"url": f"data:image/png;base64,{image_data}"}
                },
                {
                    "type": "text",
                    "text": "Identify the UI bugs visible in this screenshot."
                }
            ]
        }
    ],
)
print(response.choices[0].message.content)

Via Anthropic-compatible endpoint in Claude Code:

{
  "model": "qwen3.8-max",
  "base_url": "https://api.qwencloud.ai/anthropic",
  "api_key": "YOUR_QWEN_API_KEY"
}

The official API guide lists low, medium, and xhigh reasoning effort. The official guide also provides an OpenAI Responses-compatible configuration for Codex and an Anthropic-compatible endpoint for Claude Code, plus Qwen Code, Qoder CLI, and OpenClaw integrations.

Qwen3.8 Max vs Kimi K3: The Direct Comparison

Both models launched within weeks of each other. Both target the same frontier agent use case. Here is what the evidence actually shows:

Kimi K3 activates far fewer parameters per token at 32B versus 95B, making it faster and cheaper per output token. Qwen3.8 Max leads on OSWorld and SWE-bench Pro. Kimi K3 leads on Terminal-Bench 2.1. Neither wins cleanly across all categories.

The sharpest summary of the difference: K3 shipped a full independent benchmark table at launch. Qwen3.8 Max shipped vendor scores. That can change with one announcement, but it matters for teams making production decisions today.

Who Should Use Qwen3.8 Max

The model's benchmark profile maps clearly to specific workloads:

Use Qwen3.8 Max for computer use agents, document parsing at scale, instruction-following pipelines where consistency across many tool calls is critical, and long-context research automation where PaperBench-class performance matters.

Alibaba's primary demonstration involves autonomous software development extending beyond ten days. While enterprises should treat these demonstrations as vendor claims until independently reproduced, they align with a growing interest in persistent coding agents that operate continuously rather than interactively.

Use a different model for the hardest SWE-level coding tasks. Qwen3.8-Max results support a narrow conclusion: it is competitive across coding, research, tool use, long context, documents, computer use, and video. They do not support a universal crown.

Conclusion

Qwen3.8 Max is the clearest signal yet that Alibaba is serious about the frontier. 2.4 trillion parameters, 95 billion active per token, a one-million-token context window, native multimodal input, and API pricing below competing flagships.

The benchmark story is honest: strong on terminal agents, computer use, instruction following, and document intelligence. Not yet the top choice for the hardest software engineering benchmarks. The generational improvement over Qwen3.7-Max is real, with DeepSWE 1.1 jumping from 21.6 to 56.6 and FrontierSWE from 40.7 to 73.5.

The one independent data point available, the 80/100 on a real-world architecture task versus Kimi K3's 83, and zero failed tool calls across 44 attempts, suggests a model that is reliable under agent load. That is the detail that matters more than any benchmark row for teams building production agents.

The open weights are coming. When they land on Hugging Face, the calculus changes for every team running self-hosted inference. Until then, the API is live, the pricing is clear, and the benchmarks are available to test against your own workloads.

Test it. Compare it. The era of trusting one lab's benchmark table without verification is over, and Qwen3.8 Max is honest enough in its results to reward that scrutiny.

FAQs