I have been tracking the Qwen model family since the early days, and honestly, the release cadence from the Qwen team keeps getting more impressive. But this one — Qwen3.6-35B-A3B — is something I had to stop and write about immediately. Not because of the marketing, but because of what it actually does under the hood and how it is positioned for real agentic coding work.
First, What Even Is a MoE Model?
Before I jump into the Qwen3.6-35B-A3B specifics, let me quickly ground you on the architecture if you are new to this concept.
MoE stands for Mixture of Experts. In a traditional dense model, when you send a token through the network, every single parameter in the model participates in processing that token. If you have a 27 billion parameter dense model, all 27 billion parameters are active for every single token. That is computationally expensive.
A MoE model works differently. It has a large number of total parameters, but only a small subset — called the "active parameters" — actually compute anything for any given token. The model has a "router" layer that dynamically decides which expert sub-networks should handle each token. The rest of the model sits idle for that particular computation.
This is why Qwen3.6-35B-A3B can have 35 billion total parameters but only activate 3 billion of them at a time. You get the learned capacity of a 35B model but the inference cost of a 3B model. That is the core engineering trick here.
What the Qwen Team Released
Qwen3.6-35B-A3B is a fully open-source sparse MoE model with 35 billion total parameters and 3 billion active parameters. The model supports both multimodal thinking (vision + language) and non-thinking modes, and it is available in the following ways:
Qwen Studio — for interactive chat directly in the browser
Alibaba Cloud Model Studio API — accessible as qwen3.6-flash via OpenAI-compatible endpoints
Open weights — downloadable from Hugging Face and ModelScope for self-hosting
The key focus of this release is agentic coding. The Qwen team is not positioning this as a general-purpose chatbot update. This is specifically designed for coding agents — the kind of tasks where a model needs to autonomously navigate a codebase, write code, execute terminal commands, fix bugs, and iterate without hand-holding from a human at every step.
The Numbers That Actually Matter
I have seen a lot of benchmark tables. Most of the time, I look at them and shrug because the delta between models is within noise. But the Qwen3.6-35B-A3B benchmarks made me look twice.
![qwen3.6_35b_a3b_score]()
Related Image: © Qwen
On SWE-bench Verified
SWE-bench Verified is currently the gold standard for evaluating real-world software engineering tasks. The model is given a GitHub issue and has to produce a patch that fixes it, with no guidance on which files to touch or how.
| Model | SWE-bench Verified |
|---|
| Qwen3.5-27B (dense, 27B active) | 75.0 |
| Qwen3.5-35B-A3B (previous MoE) | 70.0 |
| Qwen3.6-35B-A3B (new MoE) | 73.4 |
| Gemma4-31B | 52.0 |
The new model jumps 3.4 points over the previous MoE version and gets within 1.6 points of the dense Qwen3.5-27B — a model that is using roughly 9x more active parameters per token. That is a remarkable efficiency gain.
On Terminal-Bench 2.0
This benchmark tests agentic terminal tasks — real shell commands, file manipulation, environment setup. The kind of thing that trips up models that are good at writing code but cannot actually use a system.
Qwen3.6-35B-A3B scores 51.5 here, which beats every other model in the comparison, including the dense Qwen3.5-27B at 41.6. With 3 billion active parameters, it is outperforming a model with 27 billion active parameters on raw terminal agentic tasks.
On QwenWebBench
This is an internal benchmark for frontend code generation across 7 categories including Web Design, Games, SVG, Data Visualization, Animation, and 3D. Qwen3.6-35B-A3B scores 1397 on this benchmark compared to 1068 for Qwen3.5-27B and 1197 for Gemma4-31B.
If you do frontend development or build tools that generate UI code, this number is very relevant.
Vision and Multimodal Capabilities
One thing I appreciate about the Qwen3.6 family is that it does not treat vision as an afterthought. Qwen3.6-35B-A3B is natively multimodal, and the results on vision benchmarks are genuinely competitive.
On RealWorldQA — a benchmark for understanding real-world images with practical questions — it scores 85.3, beating Claude Sonnet 4.5 (70.3) and Gemma4-31B (72.3) by a wide margin.
What is particularly interesting is the spatial intelligence performance. On RefCOCO, which tests a model's ability to locate specific objects in images based on natural language descriptions, it scores 92.0 compared to the previous Qwen3.5-35B-A3B which scored 89.2. On ODInW13, an object detection benchmark, it scores 50.8 versus the previous version's 42.6. That is a significant jump in spatial reasoning capability.
For document understanding tasks like OmniDocBench1.5, it scores 89.9, which is the best in its comparison group.
How to Use It
API Access via Alibaba Cloud Model Studio
If you want to call this model through an API, the setup is straightforward. The endpoint supports OpenAI-compatible protocols, so you do not need to rewrite any tooling.
from openai import OpenAI
import os
client = OpenAI(
api_key=os.environ.get("DASHSCOPE_API_KEY"),
base_url="https://dashscope-intl.aliyuncs.com/compatible-mode/v1",
)
messages = [{"role": "user", "content": "Review this Python function for edge cases."}]
completion = client.chat.completions.create(
model="qwen3.6-flash",
messages=messages,
extra_body={
"enable_thinking": True,
},
stream=True
)
for chunk in completion:
if not chunk.choices:
continue
delta = chunk.choices[0].delta
if hasattr(delta, "content") and delta.content:
print(delta.content, end="", flush=True)
Note the enable_thinking flag. When this is set to True, the model runs through an internal reasoning trace before generating the final answer. For agentic coding tasks, the team recommends also enabling preserve_thinking: True, which keeps the reasoning context across multiple turns in a conversation. This is important for long multi-step coding sessions where dropping the reasoning history would cause the model to lose context about decisions it made earlier.
API Endpoints by Region
The Alibaba Cloud Model Studio has multiple regional endpoints:
Singapore: https://dashscope-intl.aliyuncs.com/compatible-mode/v1
Beijing: https://dashscope.aliyuncs.com/compatible-mode/v1
US (Virginia): https://dashscope-us.aliyuncs.com/compatible-mode/v1
For developers in India and Southeast Asia, the Singapore endpoint is typically the best choice for latency.
Using Qwen3.6-35B-A3B with Claude Code
This is the part that I find genuinely clever. Alibaba Cloud Model Studio also exposes an Anthropic-compatible API endpoint, which means you can point Claude Code directly at Qwen3.6-35B-A3B and use it as the backend model.
# Install Claude Code
npm install -g @anthropic-ai/claude-code
# Configure environment variables
export ANTHROPIC_MODEL="qwen3.6-flash"
export ANTHROPIC_SMALL_FAST_MODEL="qwen3.6-flash"
export ANTHROPIC_BASE_URL=https://dashscope-intl.aliyuncs.com/apps/anthropic
export ANTHROPIC_AUTH_TOKEN=<your_dashscope_api_key>
# Launch Claude Code
claude
You get the Claude Code interface and tooling with Qwen3.6-35B-A3B doing the actual computation behind it. This is useful if you are already invested in the Claude Code workflow but want to experiment with different model backends, or if cost efficiency is a concern for your team.
Self-Hosting with Open Weights
If you want to run this model yourself — which makes sense for compliance reasons or if you are running workloads that cannot send data to external APIs — the weights are available on Hugging Face and ModelScope.
The efficiency of 3B active parameters matters a lot here. In practice, this model can be served on hardware that would normally only be capable of running a 3B dense model. You can run it on a single A100 or even a well-specced A6000 setup, which dramatically reduces the infrastructure cost compared to running a full dense 27B or 35B model.
A Note on the preserve_thinking Feature
The release notes specifically highlight a feature called preserve_thinking. This deserves a bit more explanation because it is more meaningful than it might first appear.
In standard multi-turn conversations, thinking content (the internal reasoning trace) is typically discarded after each response. The model generates its reasoning, produces an answer, and then in the next turn it only receives the final answer as context — not the thinking.
For simple Q&A, this is fine. But for agentic tasks — where you are doing things like "analyze this repository, then write a test suite, then fix the failing tests, then optimize the bottlenecks" — losing the thinking context is a real problem. The model's reasoning about the repository structure, about why it made certain architectural choices, gets dropped between turns.
With preserve_thinking: True, the thinking content from previous turns is retained in the message history. The model can refer back to its earlier reasoning. This creates a much more coherent long-horizon task execution, which is exactly what coding agents need.
Why This Model Matters for the Ecosystem
I want to zoom out for a moment from the benchmark numbers.
The reason Qwen3.6-35B-A3B is interesting is not just performance. It is what it represents for the broader AI ecosystem:
Open-source MoE at this scale is still relatively rare. Most capable MoE models have been proprietary. Having an open-weight 35B MoE model with strong agentic coding performance means researchers, startups, and enterprises can actually inspect, fine-tune, and deploy this without API dependency.
The 3B active parameter constraint is a forcing function for efficiency research. The Qwen team had to make architectural decisions that squeezed maximum capability out of minimal compute. The techniques that make this work — better expert routing, more efficient attention patterns, improved training data curation — are the same techniques that will make future models better.
Multimodal capability in a coding-focused model is underrated. Most coding tools are text-only pipelines. But real codebases have screenshots, architecture diagrams, database schemas as images, UI mockups. A model that can natively reason over images alongside code opens up workflows that are not possible with text-only coding agents.
Limitations to Keep in Mind
I do not want this to read like a press release, so let me be direct about what I see as the real-world limitations:
The benchmark numbers are evaluated with specific scaffold setups — internal agent scaffolds, 200K context windows, temperature 1.0, specific tooling. Your results in production will vary based on your own scaffolding and the specific nature of your tasks.
The model also sits below Qwen3.5-27B on several general agent benchmarks like VITA-Bench and Tool Decathlon. It is specifically stronger on coding tasks, but if you need a general-purpose agent for diverse task types, the tradeoff is more nuanced.
And of course, being a MoE model means that while inference compute is lower, memory footprint for the full weight matrix is still significant. You need to load all 35B parameters into memory even though only 3B are active per token. So self-hosting still requires substantial RAM/VRAM.
My Take
As someone who has followed Alibaba Cloud's AI infrastructure evolution from the early Qwen days, this release feels like a real maturation in direction. The team is not just building a more capable general model — they are building something specifically optimized for the developer workflow, with clear integration paths for the tools that engineers actually use (Claude Code, terminal agents, API-first workflows).
The efficiency story is compelling. If the performance holds up in real-world agentic coding tasks outside the benchmark setup, Qwen3.6-35B-A3B represents a serious option for teams that want strong coding agent capability without the cost and infrastructure burden of running much larger dense models.
Worth experimenting with. I will be putting it through its paces on some real repository tasks and sharing what I find.