Qwen3-Max-Thinking

Qwen3-Max-Thinking

The reasoning variant of Alibaba's trillion-parameter flagship. Read the benchmark conditions before the benchmark numbers.

The 100% Comes With a Condition

Qwen report perfect 100-point scores on AIME 25 and HMMT — two of the harder mathematics competitions used to evaluate reasoning models.

And they state the condition every time they state the result:

By integrating a code interpreter and leveraging parallel test-time compute techniques.

Read that as a system description, not a model description.

A code interpreter means the model executes code to check its arithmetic. On a mathematics benchmark, that removes an entire class of failure — a correct method with a slipped calculation.

Parallel test-time compute means running several reasoning paths and selecting among them. More attempts, better odds, and a wall-clock and token cost proportional to the number of paths.

Neither is cheating. Both are legitimate techniques, both are documented, and Qwen name them plainly rather than burying them in a footnote. But a result produced with tools and scaled inference is not a result the bare model produces, and reproducing it means reproducing both.

The Number That Describes the Model

Two other figures are more informative, precisely because they resist the same treatment.

HLE is the honest headline. Humanity's Last Exam is built to be Google-proof — questions that cannot be answered by pattern-matching or retrieval. A code interpreter does not help with a question that has no calculation in it.

Reported figures place it ahead of frontier competitors on that benchmark by a double-digit margin, which is the claim worth testing on work you care about.

GPQA at 85.4 is strong and not saturated — which is the point. Mathematics benchmarks with tool access have stopped discriminating between top models; science questions have not.

What to take from the pair. A perfect score on a saturated benchmark tells you the model is in the top tier. A leading score on an unsaturated one tells you where it sits inside that tier.

Heavy Mode: Iterative Refinement

The distinctive inference behaviour.

Heavy mode refines reasoning iteratively, drawing on prior steps during inference — rather than producing one chain of thought and committing to it.

That is a different mechanism from the effort levels elsewhere in this catalogue. Effort sets how deep a single pass goes. Iterative refinement lets a later step reconsider an earlier one.

Where that earns its cost. Problems where the first approach is wrong and the error is only visible after you have followed it through — which is most hard problems, and exactly the case a single-pass reasoning model handles worst.

Adaptive Tool Use

The model autonomously invokes Search, Memory, and Code Interpreter mid-conversation rather than waiting to be told which to use.

Three tools, three different jobs:

Search for facts outside the model's training. Memory for state across a long conversation. Code Interpreter for anything that needs computing rather than recalling.

Autonomous invocation is the operative word. The model decides mid-conversation that a step needs a tool, calls it, and continues — which is the behaviour behind the mathematics results, and the behaviour that makes a reasoning model useful on questions with a factual component.

Specifications

Context is reported inconsistently — 262K in most sources, 128K in at least one. Confirm the figure on your own path before designing around it.

Capabilities

Training at Scale

Two engineering results Qwen publish alongside the model, and both are about making the training possible rather than about the model's behaviour.

A 30% relative increase in Model FLOPs Utilisation over the previous generation, from a multi-level pipeline parallelism strategy.

A 3× throughput improvement over context parallelism for long-context training, from a chunking strategy — which is what enabled training at a 1M-token context length.

That second figure explains something. Long-context capability is usually added after pre-training through positional extension. Here the training infrastructure was built to handle the length directly, which is a different and more expensive path to the same window.

Using Qwen3-Max-Thinking on DEVUP AI

Base URL: https://api.devupai.com/v1 · Model ID: Qwen/Qwen3-Max-Thinking

Python

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["DEVUP_API_KEY"],
    base_url="https://api.devupai.com/v1",
)

response = client.chat.completions.create(
    model="Qwen/Qwen3-Max-Thinking",
    messages=[
        {"role": "user", "content": "Hello world!"}
    ],
    max_tokens=1024,
)

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

Node.js

import DevupAI from "devupai";

const client = new DevupAI({
  apiKey: process.env.DEVUP_API_KEY,
});

async function main() {
  const response = await client.chat.completions.create({
    model: "Qwen/Qwen3-Max-Thinking",
    messages: [{ role: "user", content: "Hello world!" }],
    max_tokens: 1024,
  });

  console.log(response.choices[0].message.content);
}

main();

cURL

curl -X POST "https://api.devupai.com/v1/chat/completions" \
  -H "Authorization: Bearer $DEVUP_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "Qwen/Qwen3-Max-Thinking",
    "messages": [
      { "role": "user", "content": "Hello world!" }
    ],
    "max_tokens": 1024
  }'

Giving It a Calculator

The published mathematics results used a code interpreter. If you want that behaviour, supply one.

import json
import subprocess

TOOLS = [
    {
        "type": "function",
        "function": {
            "name": "run_python",
            "description": (
                "Execute Python code in an isolated sandbox and return stdout, stderr, and the "
                "exit code. Use this to verify arithmetic and check numeric results."
            ),
            "parameters": {
                "type": "object",
                "properties": {"code": {"type": "string"}},
                "required": ["code"],
            },
        },
    },
]


def run_python(code: str) -> dict:
    """Replace with your real sandboxed execution. Never run model-generated code unsandboxed."""
    raise NotImplementedError


HANDLERS = {"run_python": run_python}

conversation = [
    {
        "role": "system",
        "content": (
            "Solve rigorously. Use the code tool to verify every numeric result rather than "
            "computing it mentally. State any assumption you rely on."
        ),
    },
    {"role": "user", "content": problem},
]

CEILING = 25

for step in range(CEILING):
    response = client.chat.completions.create(
        model="Qwen/Qwen3-Max-Thinking",
        messages=conversation,
        tools=TOOLS,
        max_tokens=32768,
    )

    message = response.choices[0].message
    conversation.append(message)

    if not message.tool_calls:
        print(message.content)
        break

    for call in message.tool_calls:
        handler = HANDLERS.get(call.function.name)
        if handler is None:
            outcome = {"error": "unknown tool", "name": call.function.name}
        else:
            try:
                outcome = handler(**json.loads(call.function.arguments or "{}"))
            except Exception as exc:
                outcome = {"error": type(exc).__name__, "detail": str(exc)}

        conversation.append({"role": "tool", "tool_call_id": call.id, "content": json.dumps(outcome)})
else:
    print(f"Stopped at the {CEILING}-step ceiling.")

🔴 Sandbox the execution. Running model-generated code in your own process means the model runs arbitrary code with your permissions. Use a container, a restricted interpreter, or a dedicated service — never exec.

The system prompt instruction matters. Telling it to verify numerically rather than compute mentally is what turns an available tool into a used one.

Approximating Parallel Test-Time Compute

The other half of the published condition, and it is something you implement rather than enable.

from collections import Counter


def solve_with_consensus(problem: str, *, paths: int = 5) -> tuple[str, int]:
    """Run several independent attempts and return the most common answer with its count."""
    answers = []

    for _ in range(paths):
        response = client.chat.completions.create(
            model="Qwen/Qwen3-Max-Thinking",
            messages=[
                {
                    "role": "system",
                    "content": "Solve step by step. End with your final answer on its own line, prefixed exactly with 'ANSWER: '.",
                },
                {"role": "user", "content": problem},
            ],
            max_tokens=32768,
        )

        content = response.choices[0].message.content or ""
        for line in reversed(content.splitlines()):
            if line.startswith("ANSWER: "):
                answers.append(line.removeprefix("ANSWER: ").strip())
                break

    if not answers:
        raise ValueError("no parseable answer across any path")

    answer, votes = Counter(answers).most_common(1)[0]
    return answer, votes


answer, votes = solve_with_consensus(problem, paths=5)
print(f"{answer}  ({votes}/5 agreement)")

The agreement count is the useful output, more than the answer itself. Five paths agreeing is a different signal from three agreeing and two disagreeing — and on a hard problem, a split vote tells you to look at it yourself.

This costs what it sounds like it costs. Five paths is five times the tokens. Reserve it for problems where being wrong is more expensive than being slow.

Reading the Reasoning

message = response.choices[0].message

trace = getattr(message, "reasoning_content", None)
if trace:
    logger.debug("reasoning: %d characters", len(trace))

print(message.content)

The reasoning is exposed by design — that is what the name refers to. Qwen position the model on accuracy, traceability, and controllable latency, and the visible chain of thought is the traceability half.

Keep the fields apart in both directions. Merging them breaks structured-output parsing and puts a working draft in front of readers expecting a conclusion.

Where It Fits

Mathematics and formal reasoning, where the benchmark results concentrate and where a code interpreter compounds the capability.

Graduate-level scientific analysis, where 85.4 on GPQA is the relevant signal.

Problems that resist retrieval — the HLE result is specifically about questions a search cannot answer.

Work where the reasoning matters as much as the conclusion, given the traceability positioning.

Multilingual deployment across 119 languages.

Less suited to latency-critical paths, high-volume classification, and anything where a fast approximate answer beats a slow correct one.

Practical Notes

Read benchmark conditions before benchmark numbers — the 100% figures include tools and scaled inference.

Supply a sandboxed code tool if you want the mathematics behaviour the published results describe.

Instruct the model to verify numerically. An available tool is not a used tool.

Implement consensus sampling yourself for the hardest problems, and treat the agreement count as signal.

Budget output tokens generously — reasoning shares the ceiling with the answer.

Confirm the context window on your own path; sources disagree.

Keep reasoning_content in its own field in both directions.

Limitations

The headline results are system results. 100% on AIME and HMMT was achieved with a code interpreter and parallel test-time compute. The bare model does not reproduce them.

Mathematics benchmarks with tool access are saturated. A perfect score stops discriminating; use HLE and GPQA to compare tiers.

Closed weights. API access only, with no self-hosted option.

Context is reported inconsistently — 262K against 128K depending on the source.

Text only. No image, audio, or video input.

Parallel test-time compute is yours to implement, and it multiplies cost by the number of paths.

Code execution requires a sandbox. Model-generated code running in your process is a security problem, not a convenience.

Published comparisons are vendor-reported or drawn from secondary coverage. Measure your own cases.

Reasoning traces are working notes. Unpolished, sometimes exploring abandoned branches, and occasionally contradicting the answer that follows.