Qwen3-Next-80B-A3B-Instruct

Qwen3-Next-80B-A3B-Instruct

Eighty billion parameters. Three active. The first model in a new architecture series.

The Efficiency Claim, Measured

Qwen state it in a form that can be checked, which is more than most efficiency claims manage.

The base model outperforms a 32-billion-parameter dense predecessor on downstream tasks — at 10% of the total training cost, and with 10× the inference throughput at long context.

Three numbers, all pointing the same direction. Cheaper to train, faster to serve, better on tasks. That combination is the argument for the entire architecture series, and this model is the first installment in it.

And the instruct model performs comparably to a flagship 235-billion-parameter model, with clear advantages on tasks requiring ultra-long context.

The RULER result is the specific evidence. On that long-context benchmark, this model outperforms a 30-billion-parameter sibling with more attention layers across all lengths — and beats the 235B flagship with more layers overall within a 256K context.

Read that carefully: it wins against a model with more attention and against a model with more depth, on long context specifically. That is the hybrid design doing exactly what it was built for.

The Architecture, Published as a Formula

Qwen give the layer layout in one line:

12 × (3 × (Gated DeltaNet → MoE) → 1 × (Gated Attention → MoE))

A four-layer block — three linear-attention layers and one full-attention layer — repeated twelve times. Forty-eight layers, of which twelve use full attention.

Why the split works. Linear attention breaks the quadratic complexity of standard attention and is far more efficient over long sequences. Full attention is exact and expensive. Three quarters of the depth costs nothing extra as input grows; one quarter provides unrestricted global mixing.

That ratio is the reason a 262,144-token window runs on three billion active parameters.

Full Specification

Gated Attention — the twelve full-attention layers

An 8:1 grouped-query ratio cuts the key-value cache to an eighth of what full multi-head attention would need — applied only where a cache exists at all.

Gated DeltaNet — the thirty-six linear layers

Mixture of Experts

Eleven experts of 512 per token — under 2.2%. The "extreme low activation ratio" Qwen describe, drastically reducing FLOPs per token while preserving model capacity.

Stability Optimisations

A named feature, and it exists for a reason worth understanding.

Zero-centered and weight-decayed layernorm, among other stabilising enhancements for robust pre-training and post-training.

Why a hybrid architecture needs this. Combining linear attention, full attention, and extreme MoE sparsity in one stack creates training instability that none of the three has alone. Routing collapses, gradients diverge, and the run fails.

Qwen addressed it at the RL stage too, using GSPO to handle the stability and efficiency challenges posed by hybrid attention combined with high-sparsity MoE during reinforcement learning.

That is the unglamorous engineering that decides whether an architecture like this ships or stays a paper.

⚠️ This Model Does Not Think

Stated explicitly: it supports only instruct (non-thinking) mode and does not generate <think></think> blocks in its output.

A separate Thinking model exists in the same series, at the same size, with the same architecture. That one supports only thinking mode — its chat template automatically includes the opening tag, so its output normally contains a closing </think> without a visible opening one.

Two models, two modes, no switch. This is not a model with reasoning disabled; it is a model trained for direct answering.

What follows practically. max_tokens covers the answer alone — nothing shares it. Latency depends on input and output length rather than on how hard the model judged the question. For an interactive endpoint, that predictability is the reason to choose this one over its sibling.

Specifications

The code is merged into the main branch of Hugging Face transformers, so no custom code path is required.

Note the extended figure is not a round million. 1,010,000 is a measured ceiling rather than a marketing number — a small sign the extension was tested rather than asserted.

Capabilities

Recommended Settings

Qwen publish these directly, and the output-length recommendation is the one most people skip.

presence_penalty between 0 and 2 is available to reduce endless repetitions — with a documented caveat: a higher value may occasionally cause language mixing and a slight performance decrease.

That caveat is worth respecting. Repetition and language mixing are both failure modes, and the parameter trades one for the other.

Standardise output format through prompting when benchmarking. For mathematics, Qwen recommend including an explicit instruction to reason step by step and place the final answer in a stated position — which is how their own numbers were produced.

Using Qwen3-Next-80B-A3B-Instruct on DEVUP AI

Base URL: https://api.devupai.com/v1 · Model ID: Qwen/Qwen3-Next-80B-A3B-Instruct

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-Next-80B-A3B-Instruct",
    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-Next-80B-A3B-Instruct",
    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-Next-80B-A3B-Instruct",
    "messages": [
      { "role": "user", "content": "Hello world!" }
    ],
    "max_tokens": 1024
  }'

At Qwen's Published Settings

response = client.chat.completions.create(
    model="Qwen/Qwen3-Next-80B-A3B-Instruct",
    messages=[
        {
            "role": "system",
            "content": "Reason step by step, then state your final answer on its own line prefixed with 'ANSWER: '.",
        },
        {"role": "user", "content": problem},
    ],
    temperature=0.7,
    top_p=0.8,
    max_tokens=16384,
    extra_body={"top_k": 20, "min_p": 0},
)

16,384 output tokens is Qwen's own recommendation for most queries on an instruct model — not a ceiling you are unlikely to reach, but the figure they consider adequate.

The step-by-step instruction is theirs too. With no thinking mode, reasoning happens inside the visible answer, and asking for it explicitly is the only way to get it.

Long-Context Work

Where the RULER result says this model is strongest.

from pathlib import Path

corpus = "\n\n---\n\n".join(
    f"### {path.name}\n{path.read_text(encoding='utf-8')}"
    for path in sorted(Path("contracts").glob("*.txt"))
)

response = client.chat.completions.create(
    model="Qwen/Qwen3-Next-80B-A3B-Instruct",
    messages=[
        {
            "role": "system",
            "content": (
                "Review this set of agreements. Identify every obligation stated in one document "
                "that contradicts an obligation in another. Quote both clauses and name both "
                "files. Report nothing you cannot quote."
            ),
        },
        {"role": "user", "content": corpus},
    ],
    temperature=0.7,
    top_p=0.8,
    max_tokens=16384,
)

print(f"input: {response.usage.prompt_tokens:,} of 262,144")

Cross-document contradiction is the task that justifies the window. A conflict between the third document and the eleventh is invisible to a pipeline that reads them one at a time.

Stay inside 262K unless you have measured past it. The extension to a million works; whether retrieval at token 900,000 matches token 200,000 is a question about your data rather than about the architecture — and Qwen's own RULER evaluation ran with YaRN enabled on 260 samples per length, which is a specific measurement rather than a general guarantee.

A Tool Loop

import json

TOOLS = [
    {
        "type": "function",
        "function": {
            "name": "lookup_order",
            "description": "Return order status, line items, and delivery events for an order ID.",
            "parameters": {
                "type": "object",
                "properties": {"order_id": {"type": "string"}},
                "required": ["order_id"],
            },
        },
    },
]


def lookup_order(order_id: str) -> dict:
    """Replace with your real data access layer."""
    raise NotImplementedError


HANDLERS = {"lookup_order": lookup_order}

thread = [{"role": "user", "content": "Order 48213 shows delivered but the customer says nothing arrived. Find out what happened."}]

CEILING = 15

for step in range(CEILING):
    response = client.chat.completions.create(
        model="Qwen/Qwen3-Next-80B-A3B-Instruct",
        messages=thread,
        tools=TOOLS,
        temperature=0.7,
        top_p=0.8,
        max_tokens=16384,
    )

    message = response.choices[0].message
    thread.append(message)

    if not message.tool_calls:
        print(message.content)
        break

    for call in message.tool_calls:
        handler = HANDLERS.get(call.function.name)
        if handler is None:
            outcome = {"error": "unknown tool", "name": call.function.name}
        else:
            try:
                outcome = handler(**json.loads(call.function.arguments or "{}"))
            except Exception as exc:
                outcome = {"error": type(exc).__name__, "detail": str(exc)}

        thread.append({"role": "tool", "tool_call_id": call.id, "content": json.dumps(outcome)})
else:
    print(f"Stopped at the {CEILING}-step ceiling.")

With no reasoning pass, each turn is fast — which is what makes a tool loop practical in wall-clock terms. The trade is that each step is a direct decision, so keep tool descriptions precise. A direct-answering model infers less than a reasoning one.

Self-Hosting

Roughly 42 GB of system memory is the stated minimum — remarkable for an eighty-billion-parameter model, and a direct consequence of the sparsity.

Supported across SGLang, vLLM, transformers, and MLX, with the code merged into the transformers main branch rather than requiring custom code.

Ascend NPU support is documented through SGLang, including single-node mixed mode and speculative decoding configuration.

An FP8 checkpoint is published by Qwen, alongside community AWQ, MLX, and GGUF builds.

Enable MTP where your serving stack supports it. Multi-token prediction is trained in and it is where the inference acceleration lives.

The reference launch sets --context-length 262144, with tensor parallelism across four devices.

Where It Fits

Long-context work at very low cost — 262K native on three billion active parameters, with a measured advantage over larger models on RULER.

High-volume production traffic, where the activation ratio makes per-call cost a fraction of what the total parameter count suggests.

Interactive endpoints, where no reasoning pass means predictable latency.

Local and edge deployment, with a ~42 GB memory requirement and official MLX support.

Multilingual work across 100+ languages and dialects.

Not for deep reasoning. The Thinking model in this series exists for that, and it is a separate model rather than a mode.

Not for vision. Text only.

Practical Notes

Use Qwen's published sampling values, and their 16,384-token output recommendation.

Ask for step-by-step reasoning in the prompt — there is no thinking mode to produce it.

Use presence_penalty cautiously; it trades repetition against language mixing.

Stay inside 262K unless you have measured the extension on your own data.

Enable MTP when self-hosting.

Route reasoning-heavy work to the Thinking model in this series rather than prompting harder here.

Keep tool descriptions precise — a direct-answering model infers less.

Limitations

No thinking mode. This model answers directly and does not produce reasoning blocks. The Thinking variant is a separate model.

Three billion active parameters is the compute ceiling per token. The sparsity buys speed and footprint, not unlimited capability.

Eighty billion parameters must be loaded even though three run per token — the saving is in compute, not in memory, though 42 GB is modest for the class.

262,144 is native; a million is extension. Behaviour at the far end is worth measuring rather than assuming, and Qwen's own long-context evaluations ran with YaRN enabled.

Text only. No image, audio, or video input, and no image generation.

presence_penalty carries a documented side effect — language mixing and a slight performance decrease at higher values.

The first installment in a new series. Architecture at this level of novelty carries more unknowns than a mature design, and tooling support, while broad, is newer.