Qwen3.5-122B-A10B: The Agentic Pick of the Medium Qwen3.5s

When Qwen released three medium-sized Qwen3.5 models on 24 February 2026, the obvious assumption was that the biggest would win everywhere. The vendor's own benchmark table says otherwise. Qwen3.5-122B-A10B leads its siblings on agentic and tool-use evaluations, but on several coding and instruction-following tests the dense 27B matches or beats it.

That makes the 122B a specific choice rather than a default. It is the one to run when a task involves many tool calls, search, or a terminal, and it costs considerably more to serve than its active-parameter count implies.

Hybrid attention plus sparse experts

Qwen3.5 changed the attention design. Instead of full attention in every layer, three out of every four layers use Gated DeltaNet, a linear-attention mechanism whose cost grows with sequence length far more gently than standard attention. Every fourth layer uses gated full attention. In the 122B that pattern repeats twelve times across 48 layers.

Each of those layers feeds a mixture-of-experts block of 256 experts, with 8 routed experts plus 1 shared expert active per token. The result is 122B total parameters and about 10B active. The model is also trained with multi-token prediction, which serving engines can use for speculative decoding.

It is natively vision-language, accepting images and video, and Apache-2.0 licensed. Native context is 262,144 tokens, extensible to roughly one million with YaRN scaling, though the card warns that static YaRN can degrade performance on shorter inputs. If the total-versus-active distinction is new, active vs total parameters explains why both numbers matter for different reasons.

Where the extra size shows up

The Hugging Face model card publishes one table covering all three medium models. The 122B pulls clearly ahead on tasks that involve acting rather than answering:

• Terminal Bench 2: 49.4, against 41.6 for the 27B and 40.5 for the 35B-A3B. GPT-5-mini is listed at 31.9.
• BFCL-V4 (function calling): 72.2, against 68.5 and 67.3.
• BrowseComp: 63.8, against 61.0 for both siblings.
• OSWorld-Verified: 58.0, against 56.2 and 54.5.
• AA-LCR (long-context reasoning): 66.9, against 66.1 and 58.5.

It also posts the best knowledge scores of the three and most of the best reasoning ones, such as 86.7 on MMLU-Pro, 86.6 on GPQA Diamond and 25.3 on Humanity's Last Exam with chain of thought. On vision it leads on MMMU at 83.9. The Terminal Bench gap is the one that matters most in practice, because terminal agents compound small reliability differences across dozens of steps. Terminal-Bench explained covers why.

Where it does not

Size does not buy a lead on everything in the same table:

• SWE-bench Verified: 72.0, against 72.4 for the dense 27B.
• IFEval: 93.4, against 95.0 for the 27B.
• LiveCodeBench v6: 78.9, against 80.7 for the 27B.
• TAU2-Bench: 79.5, against 81.2 for the 35B-A3B.

Most of these gaps are within the noise of a single benchmark run, which is the real point: on single-repository bug fixing and instruction following, the 122B is not meaningfully better than a model a fifth of its size. All of these are vendor-run numbers, so discount them accordingly and treat close calls as ties.

Serving 122B parameters for 10B of compute

Active parameters set compute per token. Total parameters set memory, and here the total is large. At 16-bit precision 122B parameters is around 244GB of weights before KV cache; even a 4-bit build is in the region of 60GB or more. The model card's vLLM and SGLang examples use eight-way tensor parallelism.

Two features soften this. Linear attention in three of every four layers keeps KV cache growth modest at long context compared with an all-full-attention model, which is why a 262K window is practical. And vLLM's --language-model-only flag skips the vision encoder for text-only deployments, freeing memory for cache.

Hosted, the trade is simpler. At the time of writing OpenRouter lists it at about $0.26 per million input tokens and $2.08 per million output, with a maximum output of 65,536 tokens. For most teams that is the realistic way to use it.

Thinking is on by default

Every Qwen3.5 model reasons before answering unless told not to. The model card states that the Qwen3-style /think and /nothink soft switches are not officially supported. To disable thinking, pass enable_thinking: false through chat_template_kwargs in the request body, or the equivalent parameter on Alibaba Cloud Model Studio.

The card recommends different sampling for each mode: temperature 1.0, top_p 0.95, presence penalty 1.5 for general thinking; temperature 0.6 with no presence penalty for precise coding; and temperature 0.7, top_p 0.8 for non-thinking use. It also advises keeping at least 128K of context available to preserve reasoning quality, and output budgets of 32,768 tokens for most tasks.

Choosing between the three medium models

A decision rule based on the published profile:

• Pick 122B-A10B for terminal agents, browsing and research agents, heavy function calling, and long-context reasoning, where its lead is largest.
• Pick Qwen3.5-27B for repository coding and strict instruction following, where it matches the 122B with a far smaller memory footprint.
• Pick Qwen3.5-35B-A3B for high-volume work where throughput and price dominate.

If you need more than all three, the Qwen3.5-397B-A17B flagship sits above them. Before committing, run your own agent tasks through the 122B and the 27B side by side and count completed tasks, not benchmark points. If the 122B does not finish noticeably more of them, the smaller model is the cheaper answer.