Alibaba shipped Qwen3.8-Max on August 3, 2026, and it is one of the more consequential model releases of the year so far. Not because of the parameter count, though 2.4 trillion is a number worth pausing on. Because of what the model is being positioned to do: run engineering work autonomously for days at a stretch, with vision as a feedback loop rather than an input format.

Qubrid AI is a day-0 provider. Qwen/Qwen3.8-Max is live on our inference platform right now, OpenAI-compatible, with the full 1M-token context window and implicit caching enabled by default.

This post is the technical breakdown we would want to read before pointing production traffic at a new flagship. It covers what Qwen 3.8 Max actually is, what the benchmark table shows (including the rows Alibaba lost), what the fine print in that table means, what it costs on Qubrid, and how to wire it into Claude Code, Cline, Codex, or your own stack in about ninety seconds.

TL;DR: Qwen 3.8 Max at a glance

Headline benchmark result: 86.6 on Terminal-Bench 2.1, ahead of both Claude Opus 4.8 and Claude Fable 5 at 84.6. Headline caveat: 67.7 on SWE-bench Pro against Fable 5's 80.0. Both are true. Most coverage will only report the first one.

What is Qwen 3.8 Max?

Qwen3.8-Max is the latest flagship in Alibaba's Qwen foundation model family, succeeding Qwen3.7-Max, which shipped in May 2026. It is a sparse Mixture-of-Experts model with 2.4 trillion total parameters, and it is the first Qwen multimodal model above the trillion-parameter mark.

The architectural detail that matters more than the headline number is the activated-parameter count. Sparse MoE models route each token through a fraction of the network. Qwen's own history makes this concrete: Qwen3-235B-A22B carries 235B total parameters but activates 22B per token, and Qwen3-30B-A3B activates roughly 3B. MarkTechPost noted at launch that Alibaba had not disclosed the activated count in its initial materials, which made serving cost impossible to model from the outside. Subsequent coverage from Apidog puts it at roughly 95B active. Treat that figure as reported rather than confirmed until Alibaba publishes a model card.

On modality, Qwen3.8-Max accepts text, images, video, and documents, and returns text. Per Alibaba's official release post, the model treats vision as a continuous feedback loop for planning, execution, and self-correction rather than a one-shot input, and the stated target workloads include long-document knowledge bases, long-video indexing, structured data extraction, and multi-step research assistants.

Alibaba has also confirmed that open weights for Qwen3.8-Max are coming, alongside a Qwen3.8-27B checkpoint. That second model is the one most teams will actually be able to self-host. A 2.4T checkpoint is a multi-node datacenter artifact; at 4-bit precision it needs roughly 1.2 TB just for weights. The 27B is the on-prem path.

Which is precisely why the API matters right now. Until those weights land and the tooling stabilizes, the hosted endpoint is the only realistic way to evaluate this model against your own workload.

Qwen 3.8 benchmarks: the full table, read honestly

Alibaba published a benchmark table at launch comparing Qwen3.8-Max against Claude Opus 4.8, Claude Fable 5, GPT-5.6 Sol, and its own Qwen3.7-Max. Here are the headline text rows.

Source: Alibaba's published launch table, as compiled by Apidog and MarkTechPost.

Where Qwen 3.8 Max genuinely wins

PaperBench: 93.0. This is the model's strongest flagship row and its most interesting one. PaperBench measures whether a model can reproduce the results of a research paper end to end. Qwen 3.8-Max leads GPT-5.6 Sol (90.5), Fable 5 (88.8), and Opus 4.8 (80.3). The generational jump is enormous: Qwen3.7-Max scored 64.8 on the same row. A 28-point leap deserves scrutiny, but it is directionally consistent with the model's long-horizon agentic story rather than an isolated outlier.

IFBench: 82.8. Instruction following is where the margin is widest. The nearest non-Qwen competitor is GPT-5.6 Sol at 72.7, with Fable 5 at 63.5 and Opus 4.8 at 62.2. Apidog's analysis flags the important context here: Qwen3.7-Max already led this row at 79.1, so this looks like a durable architectural or post-training strength for the Qwen line, not a launch-day artifact. For anyone shipping structured extraction, agent tool schemas, or constrained-format generation, this row is more predictive of production behaviour than GPQA.

Terminal Bench 2.1: 86.6. The number everyone quoted. It beats both Anthropic flagships at 84.6 and lands second behind GPT-5.6 Sol at 88.8. Terminal Bench measures agentic execution in a shell: run commands, read output, recover from failures, converge on a working end state. It is the row that most directly backs the long-horizon autonomy claims below, and it is the row most relevant if you are running coding agents rather than single-turn completions.

The multimodal sweep. The separate multimodal table is where the model looks most dominant: MathVision 95.2, LogicVista 91.9, OSWorld-Verified 86.1, Parametric CAD Bench 91.5, OmniDocBench 1.5 at 92.1, and a lead on nearly every OCR row. Note the framing caveat Apidog raises: Opus 4.8 and Fable 5 are not competing directly in that table, so it reads as a sweep partly by construction. Against Gemini 3.1 Pro and GPT-5.6 Sol, the document-intelligence and visual-reasoning rows are the model's clearest genuine differentiator.

Where it loses, and Alibaba left the losses in

SWE-bench Pro: 67.7 versus Fable 5's 80.0. On repository-scale bug fixing, the benchmark that maps most directly to "fix this issue in my actual codebase," Qwen 3.8-Max trails the leader by more than twelve points. It is ahead of GPT-5.6 Sol (64.6) and just behind Opus 4.8 (69.2). The improvement over Qwen3.7-Max's 60.6 is real. The gap to the frontier is also real. Alibaba published the number anyway, which is worth acknowledging.

HLE: 43.6. Last among the four flagships on Humanity's Last Exam, nearly ten points behind Fable 5's 53.3. HLE resists benchmark-specific tuning better than most evaluations, which is exactly why this row deserves weight. Broad-knowledge frontier reasoning is not this model's strength.

DeepSWE and the deep agentic rows. Qwen 3.8-Max also trails on DeepSWE 1.1 in Alibaba's own table, though the generational delta is dramatic: 21.6 to 56.6. FrontierSWE moved from 40.7 to 73.5, and JobBench from 31.3 to 53.4.

The pattern across the coding suite is consistent and worth internalizing: strong on terminal-driven agentic execution, mid-pack on the deepest software-engineering evaluations, dominant on multimodal and document work.

The fine print most coverage will skip

Four details change how you should read the table. Apidog's benchmark analysis surfaced these, and they are worth restating because they apply to every vendor launch table, not just this one.

1. Every number is vendor-run. Alibaba evaluated its own model and its competitors' models, choosing the benchmark versions, prompting strategies, sampling settings, and retry policies. This is standard industry practice. It is also the standard reason launch tables get revised later. Anthropic, OpenAI, and Google publish self-run tables with the same structural bias.

2. Most coding rows ran on the Claude Code harness. Alibaba ran its coding benchmarks through Anthropic's own agent harness, pointed at Qwen 3.8-Max via its Anthropic-compatible API. On one reading this is fair play, since every model runs inside the same widely used tool. On another, the Qwen coding scores are really "Qwen inside Anthropic's harness" scores, and harness choice can swing agentic results by several points. It also tells you where Alibaba expects this model to be deployed.

3. Several benchmarks are Qwen in-house. QwenSWEBench, QwenQoderBench, CoWorkBench, and RecreationBench were all built by the Qwen team. In-house evals often probe capabilities public benchmarks miss, but a strong score on your own benchmark is a different class of evidence than a strong score on SWE-bench Pro. The table presents both without visual distinction.

4. The Fable 5 footnote. Alibaba's table carries a note indicating that Fable 5 results may involve fallbacks. Whatever the technical cause, the column Qwen 3.8-Max most often trails comes with an asterisk from the people publishing it.

As of this writing, no independent evaluations of Qwen 3.8 Max exist. Artificial Analysis and the community leaderboards had not scored the model at launch. The deltas between Alibaba's table and the independent runs, when they land, will be the real story.

Our position at Qubrid: a vendor table is a claim, not a measurement. Which is the entire argument for having day-0 API access at commodity prices. Run your own eval.

The autonomous coding claim: 16 days, 265 commits, and a public repo

The reason this launch is being treated as a step change rather than an increment is the long-horizon autonomy demo, and it is more auditable than most vendor showcases.

oh-my-cli. Alibaba pointed Qwen 3.8-Max at building a CLI tool from an empty folder and let it run unattended. As of July 30, the run had gone 16 days and produced 265 commits, 127 pull requests, and 151 issues, all opened, worked, and closed by the model. The repository is public at qwen-code-dev-bot/oh-my-cli, which is the useful part. You can read the PR descriptions, check whether issues are real bugs or manufactured busywork, and judge whether the model handles its own regressions. Sixteen days of unreviewed model output is a rare artifact regardless of what you conclude about the quality.

Paper reproduction. A second run took roughly 125 hours, produced about 7,600 lines of code, and executed 33 GPU training rounds. Alibaba reports it reproduced six of the paper's findings and exceeded the paper's own result by 2.7 points on AIME24. This is the demo that backs the PaperBench score, and reproducing ML research is unforgiving work: environments break, hyperparameters hide in footnotes, and silent bugs invalidate training runs hours after the fact.

Tianchi contest. A 24-hour data science competition run, 45 submissions, final accuracy 0.853, finishing ahead of 458 of 526 human teams. It did not win. It beat 87% of the field, which is both impressive and honestly reported. Worth noting Tianchi is Alibaba's own platform.

All three showcases are documented in Alibaba's official release post, with the coding configs and run traces linked from there.

The honest read: these are vendor demos, not audits. But one of them ships a public repository, which is more than most launches offer.

Qwen 3.8 Max pricing on Qubrid AI

Here is what Qwen 3.8 Max costs on Qubrid, currently running at a 20% launch discount.

Flat across the full 1M-token context. No context-length tiering, no surprise multipliers past 200K.

The cache line is the one that matters

For agentic workloads, the implicit cache read price is the number that determines your bill, not the input price. Long-horizon agent runs re-send an enormous stable prefix on every turn: system prompt, tool schemas, repository context, prior conversation. If your prefix is stable, most of your input tokens are cache reads.

At $0.16 per million, cached input on Qubrid is roughly 14x cheaper than fresh input. Prefix stability drives your cost more than prompt length does. Structure your prompts so the invariant material comes first and the variable material comes last, and you will cut agent costs by a large multiple without touching model quality.

Worked example, a typical agentic session shape (1M cached tokens, 200K fresh input, 300K output):

1.0M cached  x $0.16  = $0.160
0.2M input   x $2.30  = $0.460
0.3M output  x $5.69  = $1.707
                       -------
                        $2.327 per session

For comparison, the same session against Claude Fable 5 at $10 / $50 is a different order of magnitude, and against Kimi K3 at $3 / $15 on Qubrid it lands materially higher on the output side. Qwen 3.8 Max is not the cheapest model on the platform. It is the cheapest way to get 1M-context multimodal frontier-adjacent agentic capability.

Thinking tokens bill as output

This is the single most important cost detail in the entire model, and it is easy to miss.

Qwen 3.8 Max is a reasoning model, and reasoning tokens bill at the output rate. The maximum reasoning budget is 262,144 tokens. A long agentic session with thinking enabled will generate a great deal of billable output that never appears in your final response.

On Qubrid, thinking is an explicit per-request flag (enable_thinking), which means you control it rather than inheriting a default. Budget above the sticker price for agentic work, and set the flag deliberately per endpoint. More on that below.

How to use the Qwen 3.8 Max API on Qubrid

The endpoint is OpenAI-compatible. If you have an OpenAI SDK integration, this is a base URL and a model ID change.

cURL

curl https://platform.qubrid.com/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $QUBRID_API_KEY" \
  -d '{
    "model": "Qwen/Qwen3.8-Max",
    "messages": [
      {"role": "user", "content": "Refactor this module to remove the circular import."}
    ],
    "max_tokens": 4096,
    "temperature": 0.7,
    "enable_thinking": true
  }'

The model ID must match exactly. qwen3.8-max, Qwen3.8-Max, and other casing variations will return an error.

Python (OpenAI SDK)

from openai import OpenAI

client = OpenAI(
    base_url="https://platform.qubrid.com/v1",
    api_key="QUBRID_API_KEY",
)

resp = client.chat.completions.create(
    # Must match the exact model ID from the docs. Variations will cause errors.
    model="Qwen/Qwen3.8-Max",
    messages=[
        {"role": "system", "content": "You are a senior backend engineer."},
        {"role": "user", "content": "Audit this service for N+1 queries."},
    ],
    max_tokens=4096,
    temperature=0.7,
    top_p=1,
    stream=False,
    extra_body={
        "enable_thinking": True,
    },
)

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

Vision input

Qwen 3.8 Max accepts images and video natively. Standard OpenAI multimodal message format:

resp = client.chat.completions.create(
    model="Qwen/Qwen3.8-Max",
    messages=[{
        "role": "user",
        "content": [
            {"type": "text", "text": "Extract every line item from this invoice as JSON."},
            {"type": "image_url", "image_url": {"url": "https://your-bucket/invoice.png"}},
        ],
    }],
    extra_body={"enable_thinking": False},
)

Given the OmniDocBench and OCR results, document extraction is one of the highest-confidence use cases for this model. If you are running invoice parsing, contract review, or statement digitization, this is worth benchmarking against whatever OCR pipeline you use today.

Function calling

tools = [{
    "type": "function",
    "function": {
        "name": "query_warehouse",
        "description": "Run a read-only SQL query against the analytics warehouse",
        "parameters": {
            "type": "object",
            "properties": {"sql": {"type": "string"}},
            "required": ["sql"],
        },
    },
}]

resp = client.chat.completions.create(
    model="Qwen/Qwen3.8-Max",
    messages=[{"role": "user", "content": "What was churn by cohort last quarter?"}],
    tools=tools,
    extra_body={"enable_thinking": True},
)

The IFBench result at 82.8 is the number to keep in mind here. Instruction adherence and schema compliance are where this model separates itself most cleanly from the competition.

Coding agents: Cline, Roo, Continue, Codex

Any agent that accepts an OpenAI-compatible base URL works without modification. Point it at https://platform.qubrid.com/v1, set the model to Qwen/Qwen3.8-Max, drop in your Qubrid key.

For Codex-style TOML configuration:

model = "Qwen/Qwen3.8-Max"
model_provider = "qubrid"

[model_providers.qubrid]
name = "Qubrid AI"
base_url = "https://platform.qubrid.com/v1"
env_key = "QUBRID_API_KEY"
context_window = 1000000

Controlling thinking with enable_thinking

On Qubrid, extended reasoning is a per-request boolean passed through extra_body:

extra_body={"enable_thinking": True}

This is the highest-leverage cost and latency control on the model, because reasoning tokens bill at the output rate. The maximum reasoning budget is 262,144 tokens. A single deep agentic turn can generate substantial billable thinking that never appears in the response body.

Turn thinking on for: multi-file refactors, debugging sessions, architecture decisions, long-horizon agent loops, research reproduction, ambiguous requirements. Anything where the model needs to plan before it acts. The 16-day autonomous showcase runs all represent this mode.

Turn thinking off for: renames, docstring passes, format conversion, classification, structured extraction from clean documents, high-volume batch OCR, mechanical edits. Deep reasoning on a rename is pure cost with no quality return.

A practical heuristic: if you cannot articulate what the model needs to plan, you do not need thinking on. Most production traffic in most applications is mechanical work paying reasoning prices because the flag was set once at integration time and never revisited.

The highest-return optimization on this model is not prompt engineering. It is auditing which of your endpoints actually need enable_thinking: True and turning it off everywhere else.

For reference, Alibaba's own Model Studio API exposes a three-level reasoning_effort parameter (low, medium, xhigh, defaulting to xhigh) rather than a boolean. If you are porting configuration from Alibaba's docs or a Qwen launch post, that is the parameter you will see referenced there.

Where Qwen 3.8 Max fits against the alternatives

Versus Qwen3.7-Max. The generational deltas in Alibaba's table are large: Terminal Bench 2.1 from 74.5 to 86.6, PaperBench from 64.8 to 93.0, SWE-bench Pro from 60.6 to 67.7, FrontierSWE from 40.7 to 73.5. Qwen3.7-Max was already a strong value model at 92.4 GPQA Diamond and 80.4 SWE-bench Verified. The upgrade case is strongest if you need multimodality or long-horizon agentic behaviour; if you are running short text completions, 3.7 remains a rational choice at a lower price point.

Versus Kimi K3. The decisive distinction is architectural, not a benchmark row: Kimi K3 is text-only. If your workload involves documents, screenshots, video, or UI automation, Qwen 3.8 Max is not competing with K3, it is in a different category. On pure text and repository-scale coding, K3 remains extremely strong and costs less on input. Both are live on Qubrid behind the same endpoint, so the useful move is running your own prompt set through both rather than reasoning from either vendor's table.

Versus Claude Fable 5 and GPT-5.6 Sol. Fable 5 leads on SWE-bench Pro, HLE, and FrontierSWE. GPT-5.6 Sol leads on Terminal Bench 2.1 and GPQA Diamond. Qwen 3.8 Max leads on PaperBench, IFBench, and the multimodal suite. At $2.30 input on Qubrid against Fable 5's list pricing, the cost-per-capability argument does not require winning every row. It requires being close enough on the rows your workload actually touches.

The practical framing: Qwen 3.8 Max is the model you route the bulk of agentic and multimodal traffic to, and you escalate the hardest repository-scale debugging to a frontier model when it fails. Routing beats picking.

What the community is saying

The open questions developers are actually asking

Two technical objections dominated the discussion around the July preview and the August launch, and both are worth taking seriously before you commit.

The activated-parameter count. Serving cost for a sparse MoE model is a function of active parameters, not total. Until that number is confirmed in a model card, nobody outside Alibaba can model inference economics for the 2.4T checkpoint from first principles. As MarkTechPost put it during the preview, total parameter count is not the same as usable compute, and the distinction matters more here than the headline figure. The practical consequence for self-hosting: a 2.4T checkpoint at 4-bit precision needs roughly 1.2 TB for weights alone, which is a multi-node deployment before you account for KV cache. This is why the Qwen3.8-27B checkpoint, not the flagship, is the realistic on-premise target for most teams.

Vendor-run benchmarks with no independent replication. The preview shipped a capability claim with no table at all, and the launch table arrived with the four caveats listed above. The skeptical position, that a self-run table evaluated on a competitor's harness is a claim rather than a measurement, is correct and applies symmetrically to every lab. Independent numbers from Artificial Analysis and the community leaderboards had not landed at time of writing.

Neither objection is a reason to skip the model. Both are reasons to run your own evaluation before you route production traffic, which is the entire argument for pay-per-token day-0 access.

Why run Qwen 3.8 Max on Qubrid AI

Day-0 access, no waitlist. We ship frontier open-weight and open-source models the day they land. Kimi K3, GLM, MiniMax, the Qwen line. No enterprise sales call, no account provisioning queue, no verification delay before you can send your first request.

One OpenAI-compatible endpoint for every model. Swapping between Qwen 3.8 Max, Kimi K3, and everything else in the catalog is a string change. You can A/B two flagships against the same prompt set in an afternoon without maintaining two SDKs, two auth schemes, and two billing relationships.

Transparent, flat pricing. $2.30 in, $5.69 out, $0.16 cached, across the full 1M context. No tiering past 200K, no per-request minimums, no committed-spend gate for launch pricing.

The path to dedicated GPUs when you outgrow per-token. This is the part most inference providers cannot offer. Every serverless workload eventually crosses a threshold where dedicated capacity beats per-token billing, and for sustained agentic traffic that threshold arrives faster than teams expect. A single 16-day autonomous run of the kind Alibaba demoed is a large, continuous, predictable token flow, which is exactly the profile where reserved GPUs win on unit economics. Qubrid runs both sides: start on the API, and when your spend curve says it is time, move to dedicated H100, H200, or B200 capacity with the same team and the same support relationship. You do not have to re-platform to graduate.

Open weights are coming, and we will host them. When Qwen3.8-Max and Qwen3.8-27B weights ship, they land in our catalog. If you want the 27B on dedicated hardware in your own VPC, that conversation starts now.

Frequently asked questions

What is Qwen 3.8 Max? Qwen3.8-Max is Alibaba's flagship Mixture-of-Experts model released August 3, 2026, with 2.4 trillion total parameters, roughly 95B active per token, a 1M-token context window, and native text, image, and video input. It succeeds Qwen3.7-Max.

How much does the Qwen 3.8 Max API cost? On Qubrid AI: $2.30 per million input tokens, $5.69 per million output tokens, and $0.16 per million implicit cache reads, currently at a 20% launch discount off list pricing of $2.87 / $7.12 / $0.20. Reasoning tokens bill at the output rate.

Is Qwen 3.8 Max open source? Not yet, but Alibaba has confirmed open weights for both Qwen3.8-Max and a smaller Qwen3.8-27B checkpoint. The 27B is the realistic on-premise deployment target; the 2.4T flagship is a multi-node datacenter artifact requiring roughly 1.2 TB for weights alone at 4-bit precision.

How does Qwen 3.8 Max compare to Claude and GPT? In Alibaba's own table it leads on PaperBench (93.0), IFBench (82.8), and Terminal Bench 2.1 (86.6, ahead of both Opus 4.8 and Fable 5 at 84.6). It trails on SWE-bench Pro (67.7 vs Fable 5's 80.0) and HLE (43.6 vs 53.3). All figures are vendor-run and were not independently verified at launch.

What is the Qwen 3.8 Max context window? 1,000,000 tokens. Maximum output is 131,072 tokens, and the maximum reasoning budget is 262,144 tokens.

Can I use Qwen 3.8 Max with my existing OpenAI integration? Yes. Point your client at https://platform.qubrid.com/v1, set the model to Qwen/Qwen3.8-Max, and use a Qubrid API key. No other code changes are required.

Is Qwen 3.8 Max good for coding? For terminal-driven agentic work and long-horizon autonomous development, the evidence is strong. For repository-scale bug fixing measured by SWE-bench Pro, it is mid-pack and trails the frontier. The pragmatic approach is routing: bulk agentic work here, escalate the hardest debugging elsewhere.

Does Qwen 3.8 Max support vision? Yes, natively. Text, images, video, and documents as input. It leads most OCR and document-intelligence rows in Alibaba's multimodal table, including OmniDocBench 1.5 at 92.1 and OSWorld-Verified at 86.1.

Start building

Qwen 3.8 Max is live on Qubrid AI now. Sign up, grab an API key, change one string in your client config, and put it against your own eval set before the independent leaderboards publish theirs.

That is the whole argument. Every benchmark table in this post is somebody's claim. Your workload is the only measurement that counts, and running it costs $2.30 per million tokens.

Get started with Qwen 3.8 Max on Qubrid AI →