Qwen3.8-Max Released: 2.4T MoE Specs and Modelflare Setup

A practical guide to Qwen3.8-Max: its 2.4T/95B MoE design, 1M-token multimodal context, reasoning controls, current Modelflare pricing, and recommended rollout configuration.

The Qwen team officially released Qwen3.8-Max on August 3, 2026. It is not the older and easily confused Qwen3-8B, and it is no longer only July's qwen3.8-max-preview: the current official API model ID is qwen3.8-max, which is also the ID used by Modelflare.

This is Qwen's largest current Max flagship, aimed at coding, professional workflows, long-horizon agents, and native multimodal work. Qwen also announced that open weights for Qwen3.8-Max and Qwen3.8-27B would arrive the following week. Until the repositories and licenses are actually published, the precise description is “open weights announced,” not “already available for local deployment.”

Core specifications

Item Qwen3.8-Max
Modelflare model ID qwen3.8-max
Architecture Mixture-of-Experts (MoE)
Total parameters 2.4T
Activated parameters per token 95B
Context length 1M tokens
Maximum non-thinking input 991K tokens
Maximum thinking-mode input 983K tokens
Maximum output 131K tokens
Maximum reasoning tokens 262K tokens
Input modalities Text, image, and video
Output modality Text
Reasoning effort low, medium, or xhigh; default xhigh
Official features Prefix Completion, Function Calling, Context Cache, Structured Outputs, Batch, and built-in Responses tools

The 2.4T figure is total model size, not the number of parameters executed for every token. The official release gives 95B activated parameters, which is more useful for understanding the compute involved in MoE inference. A 1M-token context window also does not mean every request should fill it: as input and reasoning budgets grow, latency, caching, and cost need deliberate design.

What Qwen3.8-Max targets

Qwen positions this release as a broad coding and cowork upgrade, emphasizing three kinds of work:

  • Taking a multi-day software project from an empty directory to a completed result, instead of generating isolated functions;
  • Organizing multi-step deliverables for research, data analysis, office work, design, and other professional workflows;
  • Using image and video understanding throughout planning, execution, and verification rather than as one static recognition step.

Qwen presents vendor demonstrations including more than ten days of autonomous coding and hundreds of chip-design optimization turns. These are system-level demonstrations affected by the harness, tools, environment, prompts, and judging method. They do not guarantee the same outcome in your application. Production selection should use your own repositories, documents, tool permissions, and acceptance criteria.

Choosing reasoning effort

Qwen3.8-Max supports reasoning_effort:

  • low for short answers, lightweight code explanation, and cost-sensitive work;
  • medium as a starting point for daily development, analysis, and multi-step tasks;
  • xhigh for difficult reasoning, long-horizon agents, and complex professional work; it is also the default.

Qwen says preserve_thinking is enabled by default so multi-turn work can continue from prior reasoning state. A client that reconstructs message history manually should retain the provider's reasoning fields and tool state rather than concatenating only final text. The model allows up to 262K reasoning tokens, but an available maximum is not a recommended default. Choose effort from task success and unit cost.

Current Modelflare availability

As of August 4, 2026, Modelflare lists qwen3.8-max for:

  • OpenAI Chat Completions;
  • OpenAI Responses;
  • An Anthropic Messages-compatible route.

A protocol label proves that the route exists, not that every QwenCloud-private feature is automatically forwarded. In particular, QwenCloud lists web_search, code_interpreter, web_extractor, t2i_search, and i2i_search as built-in Responses tools. Until each is verified through the exact Modelflare route, prefer client-defined function calling and treat built-in tools as unverified.

The current public snapshot for the qwen-award group is below, in USD per 1M tokens:

Billing item Price
Input $1.239
Output $3.71
Cache read $0.161
Explicit cache creation $1.547
One-hour explicit cache creation $2.4752

The group is available only to eligible API keys. Prices, eligibility, and protocol coverage can change; use Models & Pricing and per-request usage logs as the live source of truth.

Store the Modelflare API key in an environment variable:

export MODELFLARE_API_KEY='YOUR_MODELFLARE_API_KEY'

Start with a text request to validate the basic route:

curl -N -sS https://modelflare.dev/v1/chat/completions \
  -H "Authorization: Bearer $MODELFLARE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen3.8-max",
    "messages": [
      {
        "role": "user",
        "content": "Design a safe rollout plan for this service and include validation and rollback gates."
      }
    ],
    "reasoning_effort": "medium",
    "stream": true
  }'

Use medium to establish a quality, latency, and cost baseline, then raise only the tasks that genuinely need deeper reasoning to xhigh. The upstream default being xhigh is not a reason to give every batch request the maximum reasoning budget.

Rolling out multimodal input

The official model accepts text, image, and video, but multimodal content shapes vary by protocol and upstream implementation. Roll it out in three stages:

  1. Validate authentication, model access, streaming, and billing with text only;
  2. Use one fixed test image to validate the content shape, size limits, and output;
  3. Add long video, tools, or multi-turn visual feedback only after that, while checking whether retries duplicate billable work.

Do not treat image URLs, Base64 payloads, file uploads, and provider object storage as interchangeable protocols. Test the exact content block your client will send.

  1. Use a separate API key per application and confirm that its primary group lists qwen3.8-max;
  2. Start daily development and analysis at medium, lower short jobs to low, and reserve xhigh for hard long-horizon work;
  3. Design chunking and caching for long-context jobs instead of putting an entire knowledge base into every 1M-token request;
  4. Validate the Chat Completions, Responses, and Anthropic wire contracts separately;
  5. Do not make provider-built-in tools a production dependency until they pass a real request through the target Modelflare route;
  6. Compare success rate, first output, total latency, reasoning tokens, cache hits, and per-request cost on a fixed task set;
  7. Rerun regression samples when moving from the preview to the production model rather than assuming a family name guarantees identical output.

Where it fits

Qwen3.8-Max fits complex software engineering, multi-step professional workflows, long-document and video understanding, multimodal-feedback agents, and teams that want one flagship for reasoning and orchestration. It may not be the most economical default for high-throughput, low-latency text transformations. Compare it with Qwen Flash, DeepSeek V4 Flash, or another smaller model on identical inputs.

Sources and freshness

This article was verified on August 4, 2026. Open-weight status, model snapshots, prices, and protocol support can change; use the current official model page, repository license, and Modelflare catalog for production decisions.