Qwen 3.8 Max Review: Specs, Benchmarks, Pricing, and Access

Qwen 3.8 Max is Alibaba Qwen’s new flagship model for coding, professional work, long-running agents, and multimodal tasks. Officially named Qwen3.8-Max, it was announced on August 3, 2026 with 2.4 trillion total parameters, 95 billion active parameters, and a 1-million-token context window.

The launch is bigger than a routine benchmark refresh. Qwen is positioning the model as an agent that can plan, use tools, inspect visual feedback, and keep working across long task chains—not only as a chatbot that answers one prompt at a time. That puts it into the same buying conversation as the best AI models for real work, but its API price, open-weight plan, and deployment requirements deserve a closer look before you switch.

What Is Qwen3.8-Max?

Qwen3.8-Max is a large mixture-of-experts model built by Alibaba’s Qwen team. It has 2.4 trillion parameters in total but activates 95 billion parameters for each token. The model combines text, code, visual understanding, tool use, and long-horizon planning in one system designed to complete complex work from beginning to end.

Le official Qwen release describes four central goals: stronger autonomous coding, production-quality professional deliverables, longer closed-loop tasks, and native multimodal agents. In practical terms, Qwen wants the model to move from “answer this question” toward “take this objective, build a plan, use the available tools, check the result, and continue until the work is done.”

Qwen 3.8 Max Specifications

The parameter count needs context. A 2.4-trillion-parameter model is enormous, but Qwen3.8-Max does not use every parameter for every token. Its mixture-of-experts design routes each token through a smaller active portion of the network. The 95-billion active-parameter figure is therefore more useful for understanding inference behavior than the total count alone, although neither number tells you the real latency or hardware requirement by itself.

The 1-million-token context window is more immediately useful. It can hold large repositories, long document sets, extended agent histories, or months of operational records in one request. That does not guarantee perfect recall across every token, but it gives developers much more room to preserve instructions, tool output, code, and intermediate decisions without aggressive trimming.

What Can Qwen3.8-Max Do?

Autonomous coding

Qwen’s launch materials emphasize projects that run far beyond a single code generation request. The company describes autonomous development lasting more than 10 days, moving from an empty folder to a production project while adapting to errors and new requirements. That is the right direction for repository-scale agents, although buyers should still validate the model on their own languages, test suites, security rules, and deployment environment.

For everyday engineering, the practical questions are simpler: Can the model understand several files at once? Does it preserve interfaces while refactoring? Will it write tests, inspect failures, and correct its own patch? Those criteria matter more than one leaderboard score when choosing the Le meilleur modèle d'IA pour le codage.

Professional “cowork” tasks

The word “cowork” refers to work products rather than casual chat. Qwen highlights reports, research, presentations, analysis, documents, and other deliverables across hundreds of professions. A good cowork model needs to follow a brief, organize evidence, use the right format, and return something a person can edit or deliver—not just a plausible paragraph.

Long-horizon agents

Qwen also reports system-level tasks extending for hundreds of turns. Its examples include more than 500 turns of chip-design optimization and year-long e-commerce strategy simulation. These are vendor demonstrations, not a promise that every agent will run unattended for days. They do show where the product is aimed: persistent planning, closed-loop evaluation, and repeated improvement rather than isolated answers.

Multimodal planning and visual feedback

Qwen3.8-Max treats images and screens as part of the agent loop. A visual agent can inspect a page, choose an action, observe what changed, and revise its plan. That supports computer-use tasks, document understanding, interface testing, visual coding, charts, and spatial reasoning. The hard part is not merely recognizing an image; it is keeping visual observations connected to the agent’s goal over many steps.

Hands-On Tests: Useful Output, Slow Responses, and One Empty Run

I ran three independent requests against the qwen3.8-max model ID through the Anywhere OpenAI-compatible API on August 4, 2026. These are small practical checks, not an independent benchmark or a claim about every Qwen deployment. They are useful because they show both the quality of the visible answer and the behavior of the tested gateway path.

You are reviewing a Python retry helper used in a payment webhook worker.
Return exactly three parts: one corrected Python code block, three concise root-cause bullets, and one line beginning "Expected output:".

Preserve retry(operation, sleep_fn). Use no external libraries. Make at most three attempts. Sleep only before a retry, with delays 0.1 and 0.2 seconds. Return the first successful value, including a falsey value. If all attempts fail, re-raise the third exception. Do not catch BaseException.

Broken code:
def retry(operation, sleep_fn):
    last_error = None
    for attempt in range(3):
        try:
            result = operation()
        except Exception as exc:
            last_error = exc
        sleep_fn(0.1 * (2 ** attempt))
        if result:
            return result
    raise last_error

Example: operation raises ValueError("temporary") twice, then returns "paid"; sleep_fn records its arguments.

Use only these notes and do not add outside facts:
A. Official release: Qwen3.8-Max, announced 2026-08-03, 2.4T total / 95B active parameters, 1M context, Qwen Studio and QwenCloud.
B. Official launch post: $2/M input, $6/M output, $0.25/M implicit cache; open weights planned for the next week.
C. Internal note: GlobalGPT comparison workspace is live, but no dedicated Qwen3.8-Max route is verified.
D. Community comment: "I ran it locally on 4 GPUs," with no hardware, quantization, files, or license evidence.
E. Pre-launch spreadsheet: 256K context and $1.20/M input.
F. Official benchmark table: Qwen leads some rows; GPT-5.6 Sol or Fable 5 lead others; vendor-reported, not independent.

Return a Claim / Status / Best source / Publishable wording table, a 120-160 word brief, and a "Do not claim" list. Status must be Verified, Vendor-reported, Unresolved, or Outdated. Prefer current official evidence for the same field, keep official and GlobalGPT access separate, and never turn the community comment or vendor benchmarks into stronger proof.

You have two hours and two engineers to migrate a production CMS to a new deployment. Produce a compact, staged execution plan. For every stage, name the owner, time box, required evidence, an explicit go/no-go gate, and an explicit rollback gate. Include preflight checks, content and database migration, DNS or traffic cutover, smoke tests, monitoring, and the final decision. Keep the plan concise enough to use during the migration; do not add background explanation.

Retry-helper debugging

The first task used a broken retry function from a payment-webhook scenario. The prompt constrained the model to three attempts, two exact backoff delays, immediate return on success, and re-raising the third exception after total failure.

The answer identified three separate defects: unconditional sleep after every attempt, an unassigned result after exceptions, and a truthiness check that delayed or mishandled success. Its expected line was "paid" with sleep_fn arguments [0.1, 0.2].

I then ran the code locally rather than trusting the explanation. It passed three cases: two failures followed by success, a first-call falsey success value of 0, and three failures where the final RuntimeError("failure-3") had to be re-raised. This was a good engineering answer. The tradeoff was latency: the visible response took 51.577 seconds through the tested gateway.

Conflicting-evidence synthesis

The second task tested whether the model could keep current official facts separate from old notes, vendor claims, a community comment, and an unverified platform route.

The model handled the planted conflict correctly. It did not repeat the 256K context or $1.20 input price as current, did not convert a four-GPU comment into a hardware requirement, and did not claim that GlobalGPT already had a dedicated Qwen3.8-Max route. It also labelled the official benchmark table as vendor-reported. The response took 94.973 seconds, so this was another quality-first result rather than a fast extraction result.

What failed in the planning test?

A third request asked for a two-hour, two-engineer CMS migration plan with explicit go/no-go and rollback gates. The first request ended after 133.682 seconds when the upstream connection closed. A shorter retry set max_completion_tokens to 1,200, but the API reported finish_reason: "length", consumed the full reasoning budget, and returned no visible answer after 32.899 seconds.

That is a useful operational warning, but it is not evidence that Qwen3.8-Max cannot plan migrations. No plan was available to score. Through this gateway, complex planning needs a larger completion allowance, streaming, or a staged prompt so internal reasoning does not consume the entire response budget before visible text is emitted.

Qwen 3.8 Max Benchmarks

Qwen’s official benchmark package presents Qwen3.8-Max as a strong coding and multimodal agent, but the results are mixed rather than a clean sweep. It leads the listed models on some tests, sits close to the leader on others, and trails GPT-5.6 Sol or Fable 5 in several categories. That is a healthier reading than reducing dozens of tests to one “best model” label.

Selected results from Qwen’s official table

These figures come from Qwen’s own release materials. The footnotes show that the table mixes official model reports, system cards, public leaderboards, and Qwen’s in-house evaluations. Harnesses and settings also differ between some models. Use the table to identify promising strengths, then verify the shortlist on your own work before making a high-cost decision.

What the coding results mean

The clearest advantage is balance. Qwen3.8-Max is near the front across terminal work, software engineering, paper implementation, cowork tasks, web search, and instruction following. It does not need to win every row to be useful; an agent that stays consistently strong across planning, coding, tools, and visual checks may be more dependable than a model optimized for one narrow test.

The official table also shows why side-by-side testing matters. GPT-5.6 Sol leads several reasoning or terminal-oriented rows, while Fable 5 remains especially competitive on cowork, interface, and visual tasks. A separate GPT-5.6 vs Fable 5 comparison can help you translate those model families into everyday use cases before adding Qwen3.8-Max to the shortlist.

What the multimodal results mean

Qwen3.8-Max posts strong official results in multimodal reasoning, visual grounding, computer use, document work, and spatial understanding. Its 86.1 score on OSWorld-Verified is particularly relevant to screen-operating agents because it measures completing tasks inside desktop environments, not simply describing an image.

How Qwen3.8-Max Compares

There is no responsible one-line answer to “Is Qwen3.8-Max better than GPT, Claude, or Gemini?” Qwen’s own data shows category leaders changing from row to row. Product fit also depends on tool reliability, output quality, latency, regional availability, privacy controls, and the interface surrounding the model.

Qwen3.8-Max looks most compelling when you want one model to cover coding, documents, research, long tasks, and visual agents. GPT-5.6 Sol may still be the better candidate for workloads where its strongest reasoning and terminal results transfer to your environment. Fable 5 deserves a closer look for cowork and UI-heavy tasks; the Fable 5 vs Opus 4.8 comparison provides more context on that part of the decision.

The model’s planned open weights could become its largest structural advantage. API-only performance matters today, but downloadable weights create options for fine-tuning, private infrastructure, research, and regional deployment. The final value will depend on the released license, weight formats, quantization support, and the hardware needed to run the model at a useful speed.

Qwen3.8-Max API Pricing

Qwen listed the following launch prices in its official announcement:

A simple estimate is:

estimated cost = uncached input × $2/M + cached input × $0.25/M + output × $6/M

For example, a run using 10 million uncached input tokens and 2 million output tokens would cost about $32 at the launch rates before any other platform charges: $20 for input plus $12 for output. An agent that rereads a large repository on every turn can spend much more, which makes caching and context management as important as the headline input price.

Qwen3.8-Max also supports reasoning_effort controls. The official API section lists xhigh as the default for complex analysis, moyen for balancing accuracy and speed, and faible for faster, more efficient work. preserve_thinking is enabled by default. These controls can reduce cost, but they should be tested against task quality rather than treated as interchangeable modes.

Cross-provider pricing needs the same caution. A model with a lower token rate can still cost more if it needs longer prompts, more retries, or extra tool calls. The Guide des tarifs de l'API Gemini 3.1 Pro is a useful example of why context length and usage tiers matter alongside the base rate.

How to Access Qwen3.8-Max

1. Use Qwen Studio for direct evaluation

The fastest route for a first look is Qwen Studio. Start with a real task rather than a trivia prompt: provide a messy brief, a multi-file coding problem, a document set, or an image-driven workflow. Check whether the result is accurate, editable, and complete enough to save time.

2. Use the QwenCloud API for applications

Qwen3.8-Max is available through QwenCloud. The release page says its API supports industry-standard chat-completion and response protocols compatible with OpenAI’s specification, plus an interface compatible with Anthropic. That makes migration easier, but you should still review model names, parameters, streaming behavior, tool schemas, and error handling in the official documentation.

3. Connect it to coding and agent tools

Qwen’s release page includes integrations for Qwen Code, Claude Code, Codex, and OpenClaw. The model may therefore fit into an existing terminal or agent workflow without forcing a new interface. Integration support does not remove the cost of the surrounding tool, so compare the model bill with the separate Codex pricing structure before standardizing a team workflow.

Claude Code users should also separate the cost of the coding product from the external model API. The available plans and billing paths are summarized in the Claude Code pricing guide.

OpenClaw users have an additional question: which model gives the best mix of tool use, speed, and price for a specific agent. The OpenClaw model comparison provides a practical framework for making that choice instead of defaulting to the largest model.

4. Keep the multi-model workflow honest

At launch, QwenCloud is the verified production route for Qwen3.8-Max. If you also compare GPT, Claude, Gemini, or Fable alternatives, the GlobalGPT multi-model workspace can reduce tab switching across the models it supports. Use the official Qwen route for Qwen3.8-Max until a dedicated GlobalGPT model page is verified; do not assume a new model URL exists because the model was announced.

Qwen3.8-Max Open Weights

Qwen announced that Qwen3.8-Max weights would be released in the week following the August 3 launch. The same official X post also said Qwen3.8-27B would become open-weight. That is good news for local deployment and research, but the announcement alone is not enough to plan a production cluster.

Before downloading or budgeting hardware, verify five items from the final model card:

1. The exact license and commercial-use terms.
2. Official Hugging Face or ModelScope repository URLs.
3. Available precision and quantization formats.
4. Minimum and recommended CPU, GPU, RAM, and storage requirements.
5. Whether the released model matches the hosted API behavior and context length.

“Open weight” and “open source” are not always identical. Open weights tell you that the model parameters can be downloaded; the license determines what you may modify, redistribute, or use commercially. Until the repositories and license are live, pages promising a Qwen3.8-Max download, GGUF build, or precise local hardware requirement are getting ahead of the evidence.

The 27B announcement should be handled the same way. It may become the more realistic choice for local users, but its architecture, context length, memory needs, and benchmark scores should come from its own official model card—not be copied from the Max model.

Qwen3.8-Max Limitations and Best Fit

Limitations to consider

• Most launch evidence comes from Qwen. Independent evaluations may use different prompts, tools, or scoring rules.
• Long context is not perfect memory. A model can accept 1 million tokens and still miss a detail or follow a weak instruction.
• Output-heavy agents can become expensive. The $6-per-million output rate matters when a workflow produces long code, reports, or repeated reasoning traces.
• Local deployment details are incomplete until the weights and model card arrive. A 2.4T-total-parameter system will not behave like a small desktop model.
• Tool use adds another failure layer. Browser state, permissions, network errors, and poorly defined tool schemas can break an otherwise capable model.
• Launch information changes quickly. Pricing, repositories, integrations, and availability should be checked again before publication or procurement.

Who should try it now?

The simple point is that Qwen3.8-Max deserves a serious test, but not a blind migration. Use one demanding task with a clear success condition, record total tokens and retries, and compare the final deliverable—not just the first answer.

Questions fréquemment posées

When was Qwen 3.8 Max released?

Qwen3.8-Max was officially announced on August 3, 2026. The hosted model became available through Qwen Studio and QwenCloud at launch. Qwen said the open weights would be released the following week, so API availability and downloadable-weight availability should be treated as separate milestones.

Is Qwen3.8-Max open source?

Qwen announced open weights for Qwen3.8-Max, but the final repository and license determine what users may run, modify, redistribute, or use commercially. Until those files are live and verified, “open-weight release announced” is more accurate than assuming every open-source permission or local format is already available.

How many parameters does Qwen3.8-Max have?

Qwen3.8-Max has 2.4 trillion total parameters and activates 95 billion parameters per token. It uses a mixture-of-experts architecture, so the total parameter count and active parameter count describe different parts of the system. Neither figure alone predicts real-world speed or hardware demand.

What is the Qwen3.8-Max context window?

The official release lists a 1-million-token context window. That is large enough for extensive code, documents, tool output, and agent history, but maximum context does not guarantee perfect retrieval. Test the model on the position, format, and density of information used in your actual workflow.

How much does the Qwen3.8-Max API cost?

At launch, Qwen listed $2 per million input tokens, $6 per million output tokens, and $0.25 per million implicitly cached tokens. Treat these as launch prices and verify them before budgeting. Agent costs also depend on context reuse, reasoning effort, retries, and the length of generated outputs.

Is Qwen3.8-Max better than GPT-5.6 Sol or Fable 5?

Not on every test. Qwen’s official table shows Qwen3.8-Max leading some coding, search, instruction-following, and computer-use benchmarks, while GPT-5.6 Sol or Fable 5 lead others. The better model depends on the task, tool environment, latency, price, and quality of the final deliverable.

Can I run Qwen3.8-Max locally?

Qwen announced downloadable weights for the week after launch, but local feasibility depends on the final files, precision, quantization support, license, and hardware guidance. Wait for the official model card before trusting exact RAM, VRAM, or storage estimates. Smaller Qwen3.8 variants may be more practical once officially documented.

What is Qwen3.8-27B?

Qwen’s launch post says Qwen3.8-27B will also be released with open weights. The Max release article does not provide enough detail to reuse the Max model’s specifications for the 27B version. Check the dedicated model card for its architecture, context window, benchmarks, license, and download instructions.

Can I use Qwen3.8-Max on GlobalGPT?

A dedicated GlobalGPT route for Qwen3.8-Max was not verified at publication time. Use Qwen Studio or QwenCloud for direct access. GlobalGPT remains useful for comparing other available GPT, Claude, Gemini, and Fable models without switching platforms.

Verdict final

Qwen 3.8 Max is one of the most ambitious model launches of 2026: 2.4 trillion total parameters, 95 billion active parameters, a 1-million-token context window, strong official results across coding and multimodal agents, and an announced open-weight path. Its launch API pricing is competitive enough to test, especially when caching reduces repeated context costs.

The strongest reason to care is not a single benchmark win. It is the attempt to combine coding, professional deliverables, long-horizon planning, visual feedback, and tool use in one model. Start with Qwen Studio or a controlled QwenCloud evaluation, measure completed-task quality and total cost, and wait for the official weights and license before making local-deployment promises.

Primary sources checked August 4, 2026: Qwen3.8-Max official release et official @Alibaba_Qwen launch post.