Qwen3.8-Max vs Claude and GPT: It Wins Price, Not the Benchmarks

Alibaba shipped Qwen3.8-Max on August 3, 2026, with a benchmark table comparing it to Claude and GPT. I read that table closely. Qwen3.8-Max does not finish first on either coding benchmark on it. It beats both Claude models on one and loses to both on the other — and a different competitor is ahead of it each time.

What it does win is price. That is a real result. It is just not the result the table is dressed up to suggest.

The News

Qwen3.8-Max is a mixture-of-experts model with 2.4 trillion total parameters. Alibaba did not disclose how many of those parameters are active per token, which is the number that normally tells you how expensive a model is to run. Without it, “2.4 trillion” is a headline, not something you can compare to any other model’s cost profile.

It previewed on July 19, 2026, and became generally available through a hosted API on August 3. You can reach it through an OpenAI-compatible endpoint or Alibaba’s own DashScope API. Open weights are not out yet — Alibaba says they are coming “next week,” alongside a smaller Qwen3.8-27B.

Context window: 1 million tokens total. Within that budget, Alibaba publishes three separate caps: up to 991K tokens of input (983K if you turn on the model’s thinking mode), and up to 131K tokens of output in a single response. Those are independent maximums, not additive — send 991K tokens of input and only about 9K tokens of the 1M budget remain for output, well under the 131K cap.

The Benchmark Table, in Full

Here are the two coding benchmarks Alibaba chose to publish, with every model they chose to compare against:

Read both rows. On Terminal-Bench 2.1, Qwen3.8-Max beats both Claude models by 2 points — and loses to GPT-5.6 Sol by more than 2 points. On SWE-bench Pro, it loses to both Claude models, including a 12-point gap behind Claude Fable 5 — though it does edge out GPT-5.6 Sol there, 67.7 to 64.6.

Rank the four models on each row and a pattern shows up. On Terminal-Bench 2.1, Qwen3.8-Max places second, behind GPT-5.6 Sol. On SWE-bench Pro, it places third, behind both Claude Fable 5 and Claude Opus 4.8. Across both benchmarks Alibaba chose to publish, Qwen3.8-Max is never last — and never first either.

A caveat that matters more than the numbers: every score above is self-reported by Alibaba. No independent lab has reproduced them. That is normal practice for a launch announcement, but it means the table is a marketing artifact before it is anything else. Treat it as a claim, not a result.

Why This Table, and Not a Different One

Vendors do not publish every benchmark that exists. They publish the ones that make their model look good, and they choose the competitors that make the comparison interesting.

Look at what Alibaba picked here. Two benchmarks, three competitor models, and Qwen3.8-Max never places first on either — second on Terminal-Bench, third on SWE-bench Pro. That is a strange set of numbers to lead with — unless the real story is not “we beat Claude,” but “we are close enough to Claude and GPT to justify our price.”

The published table supports that second story. It does not support the first one. If you only read the headline — “Alibaba’s new model rivals Claude” — you would not know that GPT-5.6 Sol beats it on Terminal-Bench 2.1, or that Claude Fable 5 beats it by 12 points on SWE-bench Pro.

This is the general lesson, not just a Qwen lesson: when a vendor publishes its own benchmark table, read the rows where their model loses before the rows where it wins. The losses tell you what the table is actually admitting.

Where the Real Case Is: Price

Qwen3.8-Max costs $2.00 per million input tokens and $6.00 per million output tokens. Cached input tokens (context you have already sent, reused in a later call) cost $0.25 per million — an 87.5% discount off fresh input.

Put that next to the three models Alibaba benchmarked itself against:

Qwen3.8-Max is 2.5x cheaper than Opus 4.8 and GPT-5.6 Sol on input, and 5x cheaper than Fable 5. On output — where a coding agent burns most of its tokens — the gaps are wider still: over 4x cheaper than Opus 4.8, 5x cheaper than GPT-5.6 Sol, and more than 8x cheaper than Fable 5.

Note the asymmetry. Qwen’s output-to-input ratio is 3:1, while both Claude models sit at 5:1 and GPT-5.6 Sol at 6:1. The more your workload generates rather than reads, the further ahead Qwen gets.

So: it loses to Claude Fable 5 by 12 points on SWE-bench Pro while costing about an eighth as much to generate a token. Whether that trade is worth it depends entirely on the job — but it is a real trade, and it is a much better argument than “we beat Claude.” For high-volume work where you run the same kind of call thousands of times a day — batch code review, large-scale refactors, bulk migrations — it is a legitimate reason to run your own test.

(Qwen’s prices are Alibaba’s published launch figures; the Claude and GPT-5.6 Sol rows are list API pricing as of August 2026. Check current vendor pricing pages before budgeting — these move.)

That case does not need an inflated headline. “Close to frontier, priced well below it” is a good pitch on its own. Alibaba’s table just doesn’t say that plainly — it lets the reader assume more.

What to Actually Do With This

If you are choosing a model for a coding-heavy workload, do not decide from the vendor’s own table, from this article, or from any single benchmark. Benchmarks are self-reported snapshots, and coding tasks vary enough that a 2-point gap on Terminal-Bench may not predict anything about your specific codebase.

Run your own comparison instead. Qwen3.8-Max and GPT-5.6 both speak the OpenAI-compatible chat format, so one client covers both:

import os
import openai

test_prompt = "Fix the failing test in this pull request and explain the root cause."
# attach your real repo diff to test_prompt before sending

openai_compatible = {
    "qwen3.8-max": ("https://dashscope-intl.aliyuncs.com/compatible-mode/v1", "DASHSCOPE_API_KEY"),
    "gpt-5.6-sol": ("https://api.openai.com/v1", "OPENAI_API_KEY"),
}

for model, (base_url, key_env) in openai_compatible.items():
    client = openai.OpenAI(base_url=base_url, api_key=os.environ[key_env])
    reply = client.chat.completions.create(
        model=model,
        messages=[{"role": "user", "content": test_prompt}],
    )
    print(f"--- {model} ---")
    print(reply.choices[0].message.content)
    # log pass/fail against your test suite, tokens used, and cost

Claude uses a different request shape, so it needs the Anthropic SDK. The content list can include non-text blocks (like thinking output), so pull out the text block explicitly — and default to None rather than letting next() raise if a response comes back with no text block at all:

import anthropic

test_prompt = "Fix the failing test in this pull request and explain the root cause."
# attach your real repo diff to test_prompt before sending

client = anthropic.Anthropic()
reply = client.messages.create(
    model="claude-opus-4-8",
    max_tokens=2048,
    messages=[{"role": "user", "content": test_prompt}],
)
text = next(
    (block.text for block in reply.content if block.type == "text"),
    None,
)
print(text if text else "no text block in response")

Track three things per provider: whether it actually fixes the bug, how many tokens it burns doing so, and what that costs at your real call volume. That will tell you more than any row in Alibaba’s table.

Quick Summary

Related Articles

• GPT-5.6 Beats Claude Fable 5 at Coding — For 1/3 the Cost — the same price-vs-benchmark tradeoff, from a different vendor
• Claude Opus 5 — Frontier Power at Half the Price (July 2026) — Anthropic’s own answer to the price question