Qwen 3.8 Max vs Qwen 3.7 Max : quelles nouveautés et lequel les développeurs doivent-ils choisir ?

Qwen 3.8 Max vs Qwen 3.7 Max at a Glance

The 1M context figure for 3.8 matters because several early explainers still list it as unknown. QwenCloud’s current text-generation model table now lists 1M for both models. That closes one spec gap, but it does not show that 3.8 uses long context more accurately.

What Did Qwen 3.8 Max Actually Upgrade?

In its July 19 announcement, Qwen confirmed the 2.4T parameter count and said open weights would follow. Alibaba’s Qoder release note positions 3.8 as an improvement over 3.7 in coding and professional productivity, especially full-stack development, data analysis, office work, and other long-horizon tasks. A later Qwen update says the preview made a notable step on web frontend work.

Those are useful signals, but they are vendor statements rather than measured head-to-head results. No public table tells us how much better 3.8 is at resolving repository issues, completing tool-driven tasks, or preserving requirements across a long session. The active parameter count is also undisclosed, so the 2.4T headline does not tell developers the model’s serving cost or latency.

The honest upgrade story is therefore narrow: 3.8 targets better execution on the workloads 3.7 already targeted, while adding a larger model and a faster release cadence. It is not a context-window upgrade. It is not a function-calling upgrade. Whether it is a quality upgrade remains a reasonable hypothesis, not a verified result.

There is another cost. Qwen says the preview is improving continuously. That sounds attractive during evaluation, but a moving model complicates regression testing. The same prompt can behave differently after an unannounced update, and a passing test today does not guarantee the same result next week. For production teams, version stability is a feature.

Qwen 3.8 Max vs Qwen 3.7 Max for Coding

Qwen3.7-Max has a straightforward case for repository-scale coding. It accepts up to 1M tokens, supports thinking and tools, and is already callable through a conventional API. Its text-only interface is not a limitation when the agent receives source files, diffs, logs, and tool results as text.

Independent measurements also give us a baseline. Artificial Analysis scores Qwen3.7-Max at 46 on its Intelligence Index. It measured output speed at 202.2 tokens per second and time to first token at 2.62 seconds through Alibaba’s API. Those results will vary by provider and workload, but they are still more useful than a ranking claim without a methodology.

There is a trade-off. Qwen3.7-Max generated 100M output tokens during the Intelligence Index evaluation, compared with a 63M median for models in its comparison group. In plain language: it can be verbose. Fast token generation does not automatically mean a short response or a low total bill, especially when output tokens cost more than input tokens.

Qwen3.8-Max-Preview is more interesting for exploratory frontend and long-running agent work. Qwen specifically called out broad gains in web frontend, and Qoder positions it for full-stack development. I would test it on UI generation, multi-stage debugging, and tasks that mix code with office or data work. I would not move a production coding agent solely because of the model name.

A launch-week r/ClaudeCode discussion drew more than 40 comments. That is a demand signal, not a performance result. Community excitement can tell us which workloads developers care about; without controlled prompts and published outputs, it cannot tell us which model should carry production traffic.

For a fair Qwen 3.8 Max vs Qwen 3.7 Max coding test, keep the repository commit, system prompt, tools, permissions, and success criteria identical. Record tool failures, tests passed, human corrections, wall-clock time, and token use. If any of those inputs differ, the result is a demo—not a comparison.

Performance: Measured Results vs Vendor Claims

Alibaba describes Qwen3.8-Max-Preview as one of the leading frontier models and says it ranks behind only Fable 5 in its internal evaluation. The first half is plausible. The second half is not independently verifiable because Alibaba has not released the benchmark names, scores, prompts, or evaluation procedure behind it.

This evidence gap does not prove that 3.8 is worse. It means “which is better” has two answers. On expected capability, 3.8 is the likely winner. On demonstrated, reproducible performance, 3.7 currently has the stronger case.

Qwen 3.8 Max vs Qwen 3.7 Max Pricing

Qwen3.8-Max now uses standard pay-as-you-go token pricing. The earlier Preview-era Credits plan is no longer the relevant basis for this comparison.

Although Qwen3.8-Max has a lower official list price than Qwen3.7-Max, GPT Proto currently offers a much deeper discount on the older model. On GPT Proto, Qwen3.7-Max costs 80% less for input and about 73% less for output than Qwen3.8-Max.

For example, a workload using 10 million input tokens and 2 million output tokens would cost:

• Qwen3.8-Max on GPT Proto: 10 × $1.80 + 2 × $5.40 = $28.80

• Qwen3.7-Max on GPT Proto: 10 × $0.36 + 2 × $1.44 = $6.48

That makes Qwen3.7-Max the clear budget choice for high-volume, text-only workloads. However, Qwen3.8-Max adds native image and video understanding, structured outputs, a longer output ceiling, and stronger positioning for complex coding and long-horizon agents.

The cheapest request is not always the cheapest completed task. Teams should compare first-pass success, retries, tool failures, token usage, and human correction time. Start with Qwen3.8-Max when the new capabilities affect the workflow; keep Qwen3.7-Max when its lower price delivers the better cost per accepted result.

Why There Is No Matched Output Table Here

A side-by-side screenshot would look convincing. It would also be misleading right now.

Qwen3.8-Max-Preview is not available on GPT Proto, and its official documentation says the model can change throughout the preview. Comparing a fresh 3.7 API run with an undated 3.8 screenshot from a different product would mix model versions, infrastructure, tools, and possibly system prompts. I will not label that as a controlled test.

The publication-quality test is simple: run the same repository task against both models on the same day, preserve the full prompt and tool trace, and publish the raw outputs alongside the judgment criteria. Until that run exists, the absence of a sample is more honest than a decorative winner badge.

Which Model Should You Choose?

The old recommendation—“ship 3.7 and only evaluate 3.8”—no longer fits the product state.

For new work, start the evaluation with Qwen3.8-Max on GPT Proto. Keep Qwen3.7-Max when its much lower token price or an existing validated baseline produces a better cost per accepted task.

Try Qwen 3.8 Max Through GPT Proto

Qwen3.8-Max is now available through GPT Proto’s OpenAI-compatible API.

export GPTPROTO_API_KEY="your_api_key_here"

curl https://gptproto.com/v1/chat/completions \
  -H "Authorization: Bearer $GPTPROTO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen3.8-max",
    "messages": [
      {
        "role": "system",
        "content": "Inspect the existing implementation before proposing changes. Preserve current API contracts and list the verification steps for every edit."
      },
      {
        "role": "user",
        "content": "Review this repository architecture and identify the three highest-risk assumptions."
      }
    ]
  }'

The Python version uses the official OpenAI client:

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["GPTPROTO_API_KEY"],
    base_url="https://gptproto.com/v1",
)

response = client.chat.completions.create(
    model="qwen3.7-max",
    messages=[
        {
            "role": "system",
            "content": (
                "You are a senior software engineer. Return the smallest "
                "safe patch and explain each changed file."
            ),
        },
        {
            "role": "user",
            "content": (
                "Review this function for correctness and propose a tested fix: "
                "def divide_total(total, count): return total / count"
            ),
        },
    ],
)

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

The SDK adds the Bearer authorization header. Switching to another compatible model only requires changing the model string; keep a separate evaluation set so a convenient swap does not become an untested production change.

A Safe Upgrade Checklist

Start by saving a 3.7 baseline from your real workload, not a synthetic coding puzzle. Preserve the prompt, repository state, tools, expected output, latency, and token usage. Then run the same package against 3.8 Preview and inspect failures, not only the best-looking answer.

Set the migration threshold before seeing the result. For example, require the new model to pass the same tests with no increase in tool errors and no unacceptable cost change. Re-run the evaluation after major preview updates. Finally, wait for a stable model identifier and a published price before moving traffic that carries an uptime or budget commitment.

This process is less exciting than switching on launch day. It is also how you keep a model upgrade from becoming an incident.

Final Verdict

Qwen3.8-Max is now the better default Qwen model for new complex workloads. The stable API removes the largest objection in the original comparison, while multimodal input and stronger long-horizon behavior give it a broader capability ceiling.

Qwen3.7-Max is not obsolete. Its GPT Proto price makes it a strong text-only production model, especially when a workload is already tested and does not benefit from vision or extended autonomous execution.

Start new evaluations with Qwen3.8-Max. Keep 3.7 where it wins on cost per accepted task—not simply because it was released earlier.