Qwen3-Coder-Next: An 80B Coding Agent With 3B Active

The usual assumption about coding agents is that the model has to be large. Long tool-calling sessions, big repositories and unforgiving test suites all seem to demand a frontier-sized forward pass. Qwen3-Coder-Next is a direct test of that assumption: 80B parameters in total, about 3B active per token, and a model card that describes it as built "specifically for coding agents and local development".

Qwen published it in early February 2026, with a technical report following on arXiv at the end of that month. Both a base model and an instruction-tuned model are released under Apache 2.0.

Three billion active parameters, and why that is the headline

The model card lists 80B total parameters (79B excluding embeddings) and 3B activated. The mixture-of-experts layer has 512 experts, with 10 routed and 1 shared expert active per token. For comparison, the original Qwen3-Coder 480B activates 35B per token.

Active parameters decide how much compute every generated token costs. At 3B active, Next is in the same per-token class as small dense models, while carrying far more total capacity in its experts. The technical report frames the whole project as a question: how far can a strong training recipe push a model with a small parameter footprint?

Total parameters still decide memory. All 80B have to be resident, so this is not a laptop model at full precision. It is, however, within reach of a single well-equipped workstation once quantised, which is a different category from the 480B model. Active vs total parameters covers the distinction properly.

Hybrid attention is built for long sessions

The architecture is the other unusual part. The 48 layers are arranged as twelve repeating blocks, each of three Gated DeltaNet layers followed by one Gated Attention layer, with an MoE layer after each. Gated DeltaNet is a linear-attention variant: its cost does not grow with sequence length the way full attention does.

Only one layer in four uses full attention, with just 2 key-value heads. That keeps the KV cache small, which is what actually runs out first when an agent transcript grows to tens of thousands of tokens.

Native context is 262,144 tokens. That is a quarter of the 1M windows common among 2026 hosted models, and it is the main ceiling you will hit on whole-repository work.

What the scores say, and what they do not

The model card lists three agentic results:

• SWE-bench Verified — 70.6
• SWE-bench Pro — 44.3
• Terminal-Bench 2.0 — 36.2

Those are higher than the figures the 480B model's card lists for SWE-bench Pro and Terminal-Bench 2.0, with about a tenth of the active parameters. They are also vendor-run numbers, and scaffold choice moves SWE-bench scores by several points, so a hosting provider running its own harness can report a different figure for the same weights. Use them to decide whether the model is worth testing, not to rank it.

The training method is the part most likely to transfer to your work. According to the report, Qwen trained on large-scale synthetic coding tasks paired with executable environments, learning from environment feedback during both mid-training and reinforcement learning. That recipe targets the loop an agent actually runs: read a failing test, change the code, try again. Whether it transfers to your codebase is what your own evaluation should check.

Running it yourself

The card sets minimum versions: SGLang 0.5.8 or later, vLLM 0.15.0 or later. If the server will not start or runs out of memory, Qwen's own suggestion is to cut the context length to 32,768 and raise it once things work. Qwen publishes a GGUF build and points to quantised versions for llama.cpp, Ollama and LM Studio.

Use the recommended sampling settings: temperature=1.0, top_p=0.95, top_k=40. If your harness pins lower values for code, override them: running a model outside its tuned settings is an easy way to get a disappointing first impression.

Like the rest of the Qwen3-Coder line it is non-thinking only: no <think> blocks, no reasoning-effort dial. It also supports fill-in-the-middle, so one deployment can serve editor completions and an agent. Tools listed as compatible include Qwen Code, Claude Code, Cline and Kilo.

If you would rather rent, OpenRouter lists it at $0.12 per million input tokens and $0.80 per million output at the time of writing. Whether self-hosting beats that depends on utilisation; local models vs API runs the numbers.

Where it falls short

Small active footprints trade away recall. A 3B-active model has less room for long-tail knowledge than a 35B-active one, so expect more friction with obscure frameworks, legacy languages and unusual build tooling. The absence of a thinking mode means it will not spend extra tokens on a genuinely hard algorithmic problem. And 256K context means retrieval, not stuffing, on large codebases.

When to choose it

• Choose Next for self-hosted agents, high-volume CI loops, and any setup where throughput per GPU matters.
• Choose the 480B model when your tasks lean on breadth of knowledge more than iteration speed.
• Choose a hosted tier such as Qwen3-Coder-Plus when you need a 1M window and do not want to operate anything.

Then test the claim that matters: take ten tasks from your git history, run them through Next and your current model on the same harness, and compare cost per merged change rather than score.