Qwen3.8-27B vs Claude Opus 4.6 Max: What Actually Lets a 27B Model Compete

In August 2026, Alibaba released Qwen3.8-27B, and the company's benchmarks put the open model ahead of Claude Opus 4.6 Max at agentic coding (SWE-bench Pro, 61.7 to 53.4) and computer use (OSWorld-Verified, 84.3 to 72.7).

What makes this remarkable is its size. Most of today's largest open models are mixture-of-experts (MoE) models: their feed-forward blocks are split into many "experts", and a router sends each token to only a few of them. This lets a model hold hundreds of billions of parameters, sometimes more than a trillion, while each token uses only a small fraction of them. But all those parameters must stay in GPU memory, so serving one of these models usually takes several GPUs. Qwen3.8-27B is dense: every token uses all 27 billion of its parameters, and its weights fit on a single 80 GB GPU. So how does a 27B model, small by today's standards, keep up with Claude Opus?

Part of the answer is architecture. Qwen redesigned its attention layers so the model can handle very long inputs cheaply, and these redesigned layers hold 27% of its parameters. The other part is training. Four months earlier, Qwen3.6-27B shipped with exactly the same architecture and scored far lower on the agent benchmarks.

Where Qwen3.8-27B beats Opus 4.6 Max, and where it doesn't

Three of these benchmarks test agentic capabilities: the model works through long sessions of tool calls, code edits and screenshots. Qwen wins two of them, SWE-bench Pro and OSWorld-Verified, and beats Opus by 17 points on instruction following, a skill every agent depends on. Opus keeps the edge on the third, Terminal-Bench, and on the knowledge-heavy tests.

Inside the 27B: 73% standard, 27% redesigned

Most of Qwen3.8-27B follows the standard decoder recipe that nearly every open model builds on: RMSNorm and a SwiGLU feed-forward block in each of its 64 layers, with rotary position embeddings in its attention layers. The feed-forward blocks alone hold 63.6% of its 26.9 billion language-model parameters, and the embedding table and output head hold another 9.5%.

The remaining 27% is where Qwen breaks from the recipe. It sits in the token mixer, the part of each layer where a token reads from the tokens before it:

• Gated DeltaNet in 48 layers (20.7% of parameters). Instead of looking back at every earlier token, it compresses everything it has read into a fixed-size memory. A learned decay lets that memory fade old information, and the delta rule updates the value stored under each key rather than piling new information on top. If that sounds like an LSTM, it is a close cousin: the decay plays the role of the forget gate. But the update is linear, so training can process a sequence in parallel chunks instead of one token at a time.
• Gated attention in the other 16 layers (6.2%). This is standard softmax attention with a sigmoid gate on each head's output, so a head can stay almost silent when it has nothing to add. The gate costs 0.5 billion parameters, and in Qwen's own paper it made training more stable and improved results on contexts longer than those seen in training. It also almost eliminated the "attention sink", where heads park their attention on the first token.

Why Qwen redesigned the attention mechanism

Qwen introduced this hybrid design in 2025 with Qwen3-Next, to handle very long contexts efficiently. Long sequences are exactly where standard attention gets expensive: to produce each new token, an attention layer compares it with every token before it, so each token costs more than the last. A feed-forward block, by contrast, does the same work at token 10 as at token 100,000.

In Qwen3.8-27B, this adds up quickly: at about 21,800 tokens of context, comparing a new token with all the earlier ones already takes as much compute as the feed-forward block. At the full 262,144-token window, it takes twelve times as much. A Gated DeltaNet layer, with its fixed-size memory, costs the same at any length.

Attention also takes more memory as the conversation grows: every attention layer stores the keys and values of all earlier tokens, in what is called the KV cache. By keeping attention in only 16 of its 64 layers, Qwen makes that cache four times smaller: 16 GiB instead of 64 GiB for one full-length conversation.

Why agents need cheap long contexts

An agent's context fills up fast. Every file it opens, every command it runs and every screenshot it takes stays in the context, and the model reads all of it again at every step. That is exactly the workload Qwen3.8-27B's hybrid design keeps affordable.

Cheap long contexts pay off at deployment, where agent sessions run long, and probably in training too, where reinforcement learning on agent tasks generates huge numbers of such sessions. But cheap context doesn't make a model smarter. Training does.

What training added: Qwen3.6-27B vs Qwen3.8-27B

Qwen3.6-27B came out in April 2026 with exactly the same architecture as Qwen3.8-27B: the same 64 layers, the same three-to-one mix of Gated DeltaNet and attention layers, the same layer sizes. Alibaba's model card benchmarks both under identical settings:

In four months, Qwen gained 20.4 points on OSWorld-Verified, 10.4 on IFBench, 9.6 on Terminal-Bench, 8.2 on SWE-bench Pro and 6.8 on Humanity's Last Exam. On SWE-bench Pro, a dead heat with Opus became an eight-point lead; on OSWorld-Verified, a nine-point deficit became a lead of almost twelve. Only the weights changed, plus one chat-template default that keeps earlier reasoning in the context. So nearly all of these gains come from training: better data, supervised fine-tuning, reinforcement learning, or all three.

None of this makes the architecture secondary: it is what keeps long agent sessions cheap to run. Training then decides how well the model uses all that context.

Where Opus still leads

Opus still leads on coding in the terminal and on expert knowledge, but Qwen is closing the gap. In four months, it cut Opus's lead on terminal coding from 15 points to 5, and on expert questions across fields from 16 points to 9. On graduate-level science, where every model already scores around 90%, it edged closer.

And remember: Qwen3.8-27B has 27 billion parameters and fits on a single GPU. Anthropic doesn't disclose the size of Opus, but it very likely has close to a trillion parameters, or more. So a model dozens of times smaller beats a frontier giant at agentic coding and computer use. Size also explains what remains of the knowledge gap: a model stores its factual knowledge in its parameters, much of it in the feed-forward blocks, so a 27B model simply has less room for it.

Architecture, size, training: what each one explains

Architecture makes long contexts cheap, and agents live in long contexts. Size may still limit how much a 27B model can know. But training turned the same architecture, in just four months, into a model that beats Opus 4.6 Max at agentic coding and computer use.

Alibaba keeps its training recipe private, but the architecture is fully public and hasn't changed since Qwen3.5-27B in February 2026. Learn it once, and you understand three releases.

Common questions

Is Qwen3.8-27B better than Claude Opus?

On Alibaba's benchmarks, it beats Opus 4.6 Max at agentic coding, computer use and following instructions, and trails at coding in the terminal and on expert knowledge. For a 27B open model, beating a frontier model at agentic coding and computer use is a remarkable result.

Is Qwen3.8-27B a mixture-of-experts model?

No. Qwen3.8-27B is dense: every token uses all of its parameters. A mixture-of-experts model splits its feed-forward blocks into many experts and sends each token to only a few of them, so it can hold far more parameters for the same compute per token, but it needs far more GPU memory to serve. Qwen3.8-27B's weights fit on a single 80 GB GPU.

How much memory does Qwen3.8-27B need?

In 16-bit precision, the language-model weights take about 50 GiB: 26.9 billion parameters at 2 bytes each. On top of that, the KV cache takes 64 KiB per token, or 16 GiB for a full 262,144-token context, plus about 147 MiB of fixed Gated DeltaNet state per conversation. Quantized versions shrink the weights roughly in proportion to their bits per parameter.

Did the architecture change between Qwen3.6 and Qwen3.8?

No. The two model configurations match on every architectural setting, from the layer pattern and sizes to the position encoding and vocabulary. The design goes back to Qwen3.5-27B. What changed is the weights, plus one chat-template default that keeps earlier reasoning in the context.

Sources

• Qwen team, Qwen3.8-27B model card (2026).
• Qwen team, Qwen3.8-27B configuration file (2026).
• Qwen team, Qwen3.6-27B configuration file (2026).
• Qwen team, Qwen3.5-27B configuration file (2026).
• Qwen team, Qwen3-Next-80B-A3B-Instruct model card (2025).
• Songlin Yang, Jan Kautz and Ali Hatamizadeh, “Gated Delta Networks: Improving Mamba2 with Delta Rule” (2024).
• Zihan Qiu et al., “Gated Attention for Large Language Models: Non-linearity, Sparsity, and Attention-Sink-Free” (2025).