Qwen3.5-397B-A17B

Qwen3.5-397B-A17B

397 billion parameters, seventeen active, 512 experts, and vision trained in rather than bolted on.

Architecture

Eleven experts of 512 — roughly two percent of the routed pool. That sparsity is what makes a 397-billion-parameter model serve at seventeen billion parameters' compute.

The attention is the distinctive part. Rather than running full softmax attention on every layer, the stack interleaves Gated DeltaNet — linear attention, carrying sequence state at constant cost — with full attention layers placed where exact retrieval matters.

That is the same structural bet several frontier models in this catalogue now make, and it is the reason a 262K window is affordable rather than theoretical: most layers never build a cache that grows with the input.

This lineage is deliberate. The model inherits the sparse-MoE-plus-linear-attention direction from its predecessor and pushes it further — not a scaled-up dense transformer, and not a conventional MoE either.

Vision Was Trained In, Not Attached

The claim that separates this generation, and it is falsifiable.

Early fusion training on multimodal tokens, rather than a vision encoder bolted onto a finished language model.

Qwen report it outperforming their own dedicated vision-language models across reasoning, coding, and agents — while achieving cross-generational parity with the text models it succeeds.

Read what that means. A model built for both, beating the specialist models built for one. If the claim holds, it removes the usual reason to maintain two integrations: a vision model for images and a text model for everything else.

And it is checkable on your own work. Run a task you currently split across two models and compare. That comparison is more informative than any benchmark table, because the claim is about breadth rather than peak.

⚠️ Two Versions, Different Contexts

Worth settling before you build, because the naming conceals a real difference.

Same model. Different production surface.

Qwen state directly that the hosted version corresponds to this checkpoint with additional production features. So a million-token figure quoted for "Qwen 3.5" may describe the managed service rather than the weights you are calling.

The number that matters is the one your path supports. 262K is what the open checkpoint documents, and it is what the reference deployment commands configure.

Benchmark Results

On Alibaba's own scaffold:

It answers in thinking mode by default. Reasoning is the default behaviour rather than an opt-in, which means output budgets need sizing for a trace plus an answer from the first request.

⚠️ Quantisation Changes Verbosity, Not Just Precision

An independently measured failure mode, and the most practically useful thing on this page.

An INT4 quantisation of this model, with reasoning enabled, truncated roughly 70% of AIME25 answers by hitting a 32K output limit — against about 30% for the full model.

Read that carefully. The quantised model did not merely score lower. It became substantially more verbose, and a ceiling that was adequate at full precision stopped being adequate.

What to do about it.

Raise your output ceiling when moving to a quantised build. The budget that worked at full precision is not the budget that works at INT4.

Watch finish_reason. A response truncated at the limit is a failure that looks like a short answer, and on a reasoning model the trace absorbs the budget before the answer starts.

Test quantisation on your own prompts before deploying it. The quality difference is one thing; the token-consumption difference is a separate one and it is the one that breaks pipelines.

Specifications

Official quantisations are published — FP8 and GPTQ-Int4 from Qwen directly, with community GGUF builds alongside.

Capabilities

Using Qwen3.5-397B-A17B on DEVUP AI

Base URL: https://api.devupai.com/v1 · Model ID: Qwen/Qwen3.5-397B-A17B

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.5-397B-A17B",
    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.5-397B-A17B",
    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.5-397B-A17B",
    "messages": [
      { "role": "user", "content": "Hello world!" }
    ],
    "max_tokens": 1024
  }'

Watching for Truncation

On a thinking-by-default model where quantisation affects verbosity, this check belongs in your code rather than in your memory.

response = client.chat.completions.create(
    model="Qwen/Qwen3.5-397B-A17B",
    messages=[{"role": "user", "content": hard_question}],
    max_tokens=32768,
)

choice = response.choices[0]
message = choice.message

if choice.finish_reason == "length":
    # Truncated at the ceiling. The answer may be absent entirely.
    logger.warning(
        "hit output limit: %d tokens, reasoning %d chars",
        response.usage.completion_tokens,
        len(getattr(message, "reasoning_content", "") or ""),
    )

trace = getattr(message, "reasoning_content", None)
print(message.content)

finish_reason == "length" is the signal. On a reasoning model the trace consumes the budget first, so a truncated response can contain a complete chain of thought and no answer at all — which reads as an empty result rather than as an error.

Log the trace length alongside it. That tells you whether the ceiling was consumed by reasoning or by output, and those need different fixes.

Reading an Image

Vision is native here, so images and text interleave in one message.

import base64

with open("dashboard.png", "rb") as handle:
    encoded = base64.b64encode(handle.read()).decode("utf-8")

response = client.chat.completions.create(
    model="Qwen/Qwen3.5-397B-A17B",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{encoded}"}},
                {
                    "type": "text",
                    "text": (
                        "Read every figure in this chart with its label and axis unit. Separate "
                        "values printed in the image from values you read off an axis, and mark "
                        "anything illegible as unreadable rather than estimating it."
                    ),
                },
            ],
        }
    ],
    max_tokens=16384,
)

Distinguishing printed figures from axis-read estimates is worth asking for. One category belongs in a spreadsheet unchecked; the other does not, and they look identical once transcribed.

Self-Hosting

The reference deployment commands are published, and two details matter.

Two parsers are configured separately:

--reasoning-parser qwen3
--tool-call-parser qwen3_coder

Note the tool-call parser name — it is qwen3_coder, not qwen3. Using the obvious one produces tool calls that arrive as prose rather than as structured calls, which fails in a way that looks like the model ignoring your tools.

Multi-token prediction is configured explicitly, with a documented set of speculative decoding parameters. That is where the throughput gain lives; omitted, you are running the model without it.

Context is set at launch to 262,144 in the reference commands, with tensor parallelism across eight devices.

The family spans nine sizes from 0.8B up, across small and medium tiers — so if this footprint is more than your hardware allows, the alternative is within the same generation rather than a different one.

Where It Fits

Unified text and vision work in one integration, given the early-fusion training and the claim of beating dedicated vision-language models.

Long-context analysis — 262K holds a subsystem, a document set, or an extended agent history.

Agentic coding, with a SWE-bench Verified result of 76.4 on Alibaba's own scaffold.

Mathematics and reasoning, where thinking-by-default and 91.3 on AIME 2026 are the relevant signals.

Multilingual deployment across 201 languages — the widest coverage in this catalogue.

Self-hosted frontier work under Apache 2.0, with official quantisations published.

Not for latency-critical paths at default settings. Thinking runs unless disabled.

Practical Notes

Check finish_reason on every request. Thinking-by-default plus a tight ceiling produces empty answers.

Raise output budgets when moving to a quantised build — verbosity changes, measurably.

Confirm which context your path supports. The hosted version and the open weights differ.

If self-hosting, use qwen3_coder as the tool-call parser and enable MTP.

Keep reasoning_content in its own field in both directions.

Ask vision tasks to distinguish read values from estimated ones.

Limitations

Thinking runs by default. Every request reasons unless you turn it off, and the trace shares the output budget.

Quantisation increases verbosity measurably — an INT4 build truncated more than twice as often at the same ceiling.

262,144 native context, not the million figure quoted for the hosted service.

Text output only. It reads images; it does not generate them.

Seventeen billion active parameters is the compute ceiling per token, whatever the total suggests.

The tool-call parser is named for a different model. Easy to get wrong when self-hosting, and the failure is silent.

Benchmark figures come from Alibaba's own scaffold. Reproducing them means reproducing the setup.

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