TL;DR: Qwen3.8-Max is Alibaba’s 2.4T-parameter MoE model with 95B active parameters, a 1M-token context window, and support for text, image, and video inputs. At $2 per million input tokens and $6 per million output tokens, it costs less than Claude Fable 5 and GPT-5.6 Sol at current list prices. It is worth testing for long-context, multimodal, coding, and agent workflows where API cost matters. However, its weights and model-specific license have not yet been released, so teams requiring local deployment should wait for further details.

Qwen3.8-Max is Alibaba's 2.4-trillion-parameter mixture-of-experts model for coding, professional work, long tasks, and visual understanding.** Released through QwenCloud on August 3, 2026, it accepts text, images, and video, returns text, and supports a 1M-token context window.

As of August 2026, the API is live. The weights are announced for release, but they are not yet available. That distinction matters if your plan depends on local hosting, a known license, or full control of the serving stack.

Compared with Claude Fable 5 and GPT-5.6 Sol, Qwen3.8-Max has the lowest current list price and is the only one of the three that lists video input. Fable 5 costs more but is generally available through several cloud routes. GPT-5.6 Sol sits between them on price and offers a larger set of hosted tools.

The short answer: Pilot Qwen3.8-Max when API cost, video input, or a future weight release matters. Choose Fable 5 for high-budget, long-running coding and knowledge work. Choose GPT-5.6 Sol when hosted tools, computer use, and OpenAI's Responses API are central to the product.

Qwen3.8-Max may provide the reasoning, coding, and agentic capabilities behind an AI product, but the model is only one part of the user experience. Teams also need to decide how its answers will be presented and how users will act on them.

That is where generative UI comes in. Instead of returning every answer as a block of text, an application can turn Qwen3.8-Max’s output into charts, tables, forms, comparisons, and other interactive interfaces generated for the task at hand.

See generative UI in action! Enter any query to compare a standard LLM response with the interface produced when an LLM is paired with OpenUI.

Explore What Generative UI Can Do for Your Product

Qwen3.8-Max specs and current status

The official release calls this the first Qwen-Max-class model planned for a weight release. Qwen reports 2.4T total parameters and 95B active parameters, which means its mixture-of-experts design activates only part of the network for each token.

Qwen3.8-Max at a glance

Qwen3.8-Max combines a large context window with multimodal input and relatively low API pricing. Here are the specifications that matter when deciding whether to test it.

Category	Qwen3.8-Max
Model architecture	Mixture-of-experts model with 2.4T total parameters and 95B active parameters
Input formats	Text, images, and video
Output format	Text
Context window	Up to 1 million tokens
Maximum input	991K tokens
Maximum output	131K tokens
Thinking mode	Up to 983K input tokens and 262K reasoning tokens
API pricing	$2 per 1M input tokens and $6 per 1M output tokens
API access	Available through QwenCloud
Model weights	Announced but not yet released
Local deployment	Not currently available

The main limitation is deployment flexibility. Although the hosted API is available, the model weights and model-specific license have not yet been published. Teams that require local hosting should wait for those details before planning infrastructure or estimating deployment costs.

Qwen3.8-Max vs Claude Fable 5 vs GPT-5.6 Sol

The three models target demanding coding, research, and agent work, but their commercial profiles differ. Price alone does not decide the winner because models can use different numbers of tokens and tool calls to finish the same job.

Decision factor	Qwen3.8-Max	Claude Fable 5	GPT-5.6 Sol
API model ID	`qwen3.8-max`	`claude-fable-5`	`gpt-5.6-sol`
List price per 1M tokens	$2 input, $6 output	$10 input, $50 output	$5 input, $30 output
Cached input	$0.25 implicit cache; $0.17 explicit-cache read	90% input-token discount for prompt-cache hits	$0.50 per 1M cached input tokens
Context and max output	1M context; 131K max output	1M context; 128K max output	1.05M context; 128K max output
Listed inputs	Text, image, video	Text and image	Text and image
Tool surface	Function calling, structured output, web search, code interpreter, and extractor tools	Programmatic tool calls, memory, code execution, compaction, and vision	Web search, file search, code interpreter, hosted shell, computer use, MCP, and tool search
API and cloud access	QwenCloud and OpenAI-compatible or Anthropic-compatible interfaces	Generally available through Claude API, AWS, Google Cloud, and Microsoft Foundry	OpenAI API; ChatGPT access depends on plan and workspace settings
Public weights	Announced, but not posted as of August 5, 2026	No public weights	No public weights
Same sample request cost	About $0.26 for 100K input and 10K output	About $1.50 for 100K input and 10K output	About $0.80 for 100K input and 10K output
Best first test	Video or document review, cost-sensitive agents, and long-context coding	Long-running coding, research, and professional deliverables where quality outweighs token price	Tool-heavy agents, computer use, coding, research, and OpenAI-based products
Main watchpoint	Weights and license remain pending; launch scores are mainly vendor evidence	Higher token price; safety classifiers may refuse some cyber or biology requests	Higher price than Qwen; video input is not listed on the model page

Qwen3.8-Max has the clearest price advantage and broader listed input types. Fable 5 asks teams to pay more for Anthropic's top generally available model, while GPT-5.6 Sol offers the richest hosted tool set of the three. Your own task success rate and token use can reverse the list-price ranking.

How to choose between the three

Choose Qwen3.8-Max when cost per token, video input, or planned access to weights is material. It is also the strongest pricing candidate for experiments that may need many long agent runs.

Choose Claude Fable 5 when you are willing to pay more for Anthropic's top generally available model and your work centers on long coding, research, documents, or multi-stage professional tasks. Plan for explicit refusal and fallback handling.

Choose GPT-5.6 Sol when your application depends on OpenAI's hosted tools or computer use. Its current price sits between Qwen and Fable, and its model page lists support for web search, file search, code interpreter, shell, MCP, and computer use.

Do not select any of them from a single benchmark. Run the same task set, tool rules, retry cap, and acceptance test across all three, then compare finished-task cost rather than price per token alone.

What Qwen3.8-Max is built to do

Qwen positions the model around coding, professional tasks, research, visual work, and long-running agent jobs. Those categories are broad, so the useful question is what changes at the application level.

Long-running coding and tool use

The launch report describes an autonomous coding run that lasted more than ten days. Qwen links the public oh-my-cli project trace, where issues, pull requests, tests, and recovery loops can be inspected.

That trace is more useful than a short code-generation demo because it exposes the surrounding system. The model worked inside an agent runtime with task state, dispatch, tests, CI, logs, and retry paths. Teams evaluating coding agents should study that system behavior, not only the final repository.

This distinction is central to how AI agent architecture works: model quality, tools, memory, verification, and the user-facing layer all affect the result.

Long documents and visual inputs

Qwen3.8-Max can accept images and video alongside text. This makes it a candidate for document review, screenshot-based support, visual quality checks, and research tasks that combine files with tool calls.

A 1M-token context window also allows large inputs, but capacity is not the same as reliable recall. Test where key facts appear, whether citations remain attached to claims, and how quality changes near your real input size.

Business workflow automation

For business workflows, the model can interpret a request, call tools, and return structured output. A useful agent still needs permissions, data boundaries, approval points, failure handling, and logs.

If the workflow splits into several roles, use the same controls you would apply to multi-agent systems. Give each agent a narrow job, define what it may change, and require checks before actions that affect customers or company data.

What the benchmark results do and do not show

Qwen published a large score table across coding, agents, office tasks, vision, and video. Selected rows show a mixed result rather than a clean win.

Benchmark	Qwen3.8-Max	Fable 5	GPT-5.6 Sol (max)
SWE-bench Pro	67.7	80.0	64.6
PaperBench	93.0	88.8	90.5
Terminal Bench 2.1	86.6	84.6	88.8
IFBench	82.8	63.5	72.7

Run your own task set with fixed prompts, tool permissions, retry rules, and scoring. Track success rate, human correction time, latency, token use, and the cost of failed runs. A model that wins a public score can still lose on your workflow.

Qwen3.8-Max pricing and cost controls

At the current QwenCloud list price, a request with 100,000 uncached input tokens and 10,000 output tokens costs about $0.26 before tool fees: $0.20 for input and $0.06 for output.

That simple example hides three cost drivers:

Long prompts: Sending the same large instructions or documents on every turn raises input cost.
Reasoning depth: The API supports low, medium, and xhigh reasoning effort. Higher effort can consume more time and tokens.
Retries and agent loops: A failed tool call can lead to more model turns, even when the first prompt looked cheap.

Use cache-aware prompts, cap agent turns, log token use by workflow, and route simple jobs to a lower-cost model. New QwenCloud users may receive a model-specific free quota, usually valid for 90 days, but eligibility and remaining quota must be checked in the account.

Limits to address before production

The weights and license are still pending

The API is released, while the weights are only announced. Do not call Qwen3.8-Max open-source or open-weights yet. Do not estimate local GPU needs from the 2.4T parameter count alone.

When files arrive, check the license, supported precision, quantization options, serving software, memory needs, and whether the released checkpoint matches the hosted API.

The benchmark evidence comes from the vendor

The launch table is useful, but it is not an independent evaluation. Test the model against your current baseline using the same tools and time budget.

Pay close attention to long jobs. A model may start well and still drift, repeat actions, or stop checking its own work after many turns.

Long context can raise cost and hide errors

Large context windows tempt teams to send every available file. That can make relevant evidence harder to find and make failures harder to audit.

Use retrieval or staged summaries when they produce a clearer evidence trail. Keep source IDs with extracted facts, and require the final answer to point back to them.

Text output may be a weak user experience

Qwen3.8-Max can reason over visual inputs, but its listed output is text. A raw response may still leave users copying values into a spreadsheet, opening another dashboard, or asking a follow-up just to take action.

For product teams, agentic interface design patterns help decide when a result should appear as a chart, form, table, card, or report.

How to run a useful Qwen3.8-Max pilot

Start with one workflow where better reasoning or visual input could change the result. Avoid a broad “replace our model” test.

Define the job. Choose a bounded task such as reviewing a product screenshot, triaging a code issue, or drafting a sourced research brief.
Build a test set. Include normal cases, missing data, tool failures, and requests the agent must refuse or escalate.
Call the hosted API. The official endpoint supports OpenAI-compatible chat completions and responses, plus an Anthropic-compatible interface.
Set budgets. Limit turns, output tokens, tool calls, and wall-clock time. Start with medium reasoning effort, then compare low and xhigh on the hardest cases.
Score the whole workflow. Measure task success, correction time, latency, input and output tokens, and recovery after a failed tool call.
Design the result layer. Decide whether the user needs prose, a table, a chart, a form, or an approval step.

The QwenCloud first-call guide uses the OpenAI SDK. For Qwen3.8-Max, the core call follows this pattern:

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["DASHSCOPE_API_KEY"],
    base_url="https://dashscope-intl.aliyuncs.com/compatible-mode/v1",
)

response = client.chat.completions.create(
    model="qwen3.8-max",
    messages=[
        {
            "role": "user",
            "content": "Review this task and return the next three checked actions.",
        }
    ],
    reasoning_effort="medium",
)

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

Keep keys in environment variables, confirm regional endpoints, and add production logging around the call. Do not treat a successful demo as proof that the workflow is ready for real users.

When to use Qwen3.8-Max

Choose a Qwen3.8-Max API pilot if your workload needs long context, visual input, tool use, or hard reasoning and you can test it against a fixed baseline. Wait if local hosting or a known weight license is mandatory.

For customer-facing agents, judge the reasoning and the interface as one workflow. A correct answer that users cannot inspect or act on is still an incomplete product.

Ready to bring Generative UI into your product?

If you are evaluating models such as Qwen3.8-Max but still deciding how users should explore and act on their outputs, talk to the Thesys team about your use case, model stack, and interface requirements.

Schedule a Meeting

FAQs: Qwen3.8-Max

Is Qwen3.8-Max open-source or open-weights?

No, not as of August 5, 2026. Qwen has announced that weights will be released after the API launch, but the files and model-specific license are not yet posted. Describe the weights as announced, not available.

Can Qwen3.8-Max run locally?

There is no confirmed local path today because the weights and serving guidance have not been published. Wait for the files, license, precision details, and hardware guidance before estimating a local deployment.

What is the Qwen3.8-Max context window?

QwenCloud lists a 1M-token context window, with up to 991K input and 131K output. Thinking mode lists up to 983K input and 262K max reasoning. Real task quality should still be tested at your expected input size.

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

As of August 2026, QwenCloud lists $2 per million input tokens and $6 per million output tokens. Cache reads can cost less, while long prompts, reasoning, tools, and retries can raise the full workflow cost.

How does Qwen3.8-Max compare with Claude Fable 5 and GPT-5.6 Sol?

Qwen currently has the lowest list price and adds video input. Fable 5 is the most expensive and targets long coding and knowledge work. GPT-5.6 Sol is mid-priced and lists the broadest hosted tool set. Test finished-task cost before choosing.

Does Qwen3.8-Max accept images and video?

Yes. The hosted model lists text, image, and video as input types and text as its output type. Test your own screenshots, scans, charts, and videos because modality support alone does not guarantee task accuracy.

Related articles

May 2026 Security Incident

Why We're Open Sourcing OpenUI

AI Copilots: A Complete Guide to Intelligent Assistance

What Are AI Agents: Types, Capabilities, and Real-World Use

ChatKit: What It Is, What It Isn’t, and Where C1 Fits In

PowerPoint Automation Reimagined with C1 Artifacts API

The Future of AI Interfaces is Generative

MCP UI: Making AI Apps Interactive

What Is AG-UI and Why It Matters for AI-Native User Interfaces

How to design AI-Native Conversational Interfaces : From Templates to Generative UI

GPT 5 vs. GPT 4.1

How to Build Generative UI Applications

Implementing Generative Analytics with Thesys and MCP

Evolution of Analytics: From Static Dashboards to Generative UI

Why Generating Code for Generative UI is a bad idea

Building the First Generative UI API: Technical Architecture and Design Decisions Behind C1

How we evaluate LLMs for Generative UI

Generative UI vs Prompt to UI vs Prompt to Design

Generative UI: What It Is and Why It Matters