Qwen 3.5: The Complete Guide to Every Model in the Family

Qwen 3.5 isn't a single model. It's a family of eight open-weight models ranging from 0.8B to 397B parameters, all released under Apache 2.0, all natively multimodal (text, image, video), and all built on a hybrid architecture that mixes linear attention with traditional transformers. The lineup dropped in waves between February 16 and March 2, 2026, and it represents the biggest leap in open-weight AI since the original Llama release.

What makes Qwen 3.5 different from yet another model dump? Three things. First, every model — even the 0.8B — handles images and video out of the box. No separate "VL" variant. Second, the hybrid DeltaNet architecture makes long-context inference dramatically faster (up to 19x at 256K tokens). Third, the smaller models punch absurdly above their weight: the 9B beats GPT-OSS-120B on multiple knowledge benchmarks. That's a 13x size difference.

This guide covers all eight open-weight models plus the two API-only variants (Qwen3.5-Max-Preview and Qwen3.5-Plus). We'll tell you which one to pick, what hardware you need, where the models genuinely shine, and where they fall short.

Which Qwen 3.5 Model Should You Use?

This is the question that matters. Not everyone needs a 397B flagship — in fact, most users will get better results from a smaller, faster model. Here's the quick breakdown by hardware tier:

For Local Use

For API Use

Best quality: Qwen3.5-Max-Preview sits at rank 10 on LMArena's Expert leaderboard, beating GPT-5.4. No public API yet — preview only via arenas.
Production: Qwen3.5-Plus at $0.26/M input tokens. That's roughly 70% cheaper than GPT-5 series calls.
Budget: Qwen3-Max-Thinking still holds up well for batch workloads where you don't need the latest generation.

Not sure what'll run on your GPU? Check your hardware with our Can I Run tool — it covers every Qwen 3.5 model and quantization level.

Complete Model Overview

MoE vs Dense: Why It Matters for You

Five of the eight models (27B, 9B, 4B, 2B, 0.8B) are dense — every parameter fires on every token. Simple to run, consistent quality, straightforward VRAM math.

The other three (397B, 122B, 35B) use Mixture of Experts (MoE). They carry more total parameters but only activate a fraction per token. This makes them faster at inference — but they still need enough memory to hold all the experts on disk.

The 35B-A3B is the standout example. It has 35 billion total parameters but activates only 3 billion per token. The result: 196 tok/s on an RTX 4090 — faster than a dense 9B model despite having nearly 4x the total knowledge. The r/LocalLLaMA community calls it "the model that's all you need" for practical day-to-day tasks. On an RTX 3090, it still hits 111 tok/s at Q4.

The 27B Dense, by contrast, activates all 27B parameters on every token. Slower (~35 tok/s on a 3090) but denser computation. If you're doing creative writing or nuanced reasoning where every parameter counts, the 27B often produces more consistent prose. For speed-sensitive batch work, coding agents, or anything where throughput matters — the 35B-A3B wins hands down.

Hardware Requirements & Running Qwen 3.5 Locally

Every Qwen 3.5 model is available on HuggingFace with GGUF quantizations from Unsloth. The table below shows VRAM requirements across quantization levels — find your GPU's VRAM and read across to see what fits.

The sweet spots: The 9B at Q4 fits in 6GB — any modern GPU handles it. If you have 24GB (RTX 3090/4090), the 35B-A3B at Q4 is phenomenal: 196 tok/s on a 4090, 111 tok/s on a 3090. For pure quality over speed, the 27B Dense at Q4 needs ~16GB and excels at creative writing and complex reasoning.

Quantization quality matters. Community testing from Benjamin Marie shows Q8_0 adds only +0.002-0.05 perplexity over full precision — practically lossless. Q4_K_M is the standard sweet spot. Avoid Q4_0 for coding and factual tasks, where the +0.2-0.25 perplexity hit becomes noticeable.

Quick Start Commands

# llama.cpp (recommended)
./llama-server -m Qwen3.5-9B-Q4_K_M.gguf -c 32768

# Ollama (see warning below)
ollama pull qwen3.5:9b

# MLX on Mac
mlx_lm.generate --model mlx-community/Qwen3.5-35B-A3B-4bit

Warning — Ollama has serious issues with Qwen 3.5 as of March 2026. Users on r/LocalLLaMA report infinite chain-of-thought loops, completely broken tool calling (issue #14493), speeds of 15-20 tok/s where llama.cpp gets 100+ tok/s for the same model, and non-functional vision (mmproj files aren't bundled). We recommend llama.cpp server or vLLM until Ollama patches land — typically 2-4 weeks after a major release. LM Studio's thinking mode toggle is also unreliable (issue #1559).

Frameworks that work well: llama.cpp (best for single-GPU), vLLM (best for serving), MLX (best for Apple Silicon). For a full walkthrough, see our guide to running Qwen locally.

Want to check exactly which Qwen 3.5 model fits your specific GPU? Our hardware checker covers every model and quantization.

Benchmarks: Where Qwen 3.5 Wins (and Where It Doesn't)

The Flagship: 397B-A17B vs Frontier Models

The 397B is Alibaba's bid for the frontier. It competes directly with GPT-5.2, Claude Opus, and Gemini 3 Pro — and wins in specific areas while trailing in others. Here's the honest picture:

The 397B leads on instruction following, multimodal math, document understanding, and every agentic benchmark. It falls behind on competitive coding (Gemini 3 Pro dominates LiveCodeBench) and doctoral-level science (GPT-5.2 edges it on GPQA). For agentic tasks, the jump from Qwen 3's Terminal-Bench score of 22.5 to 52.5 is staggering — that's the single biggest generational improvement in the entire benchmark suite.

The Giant Killers: 9B and 35B-A3B

This is where the story gets interesting for most users. The 9B — a model that fits on any modern GPU — outscores GPT-OSS-120B across multiple knowledge benchmarks. That's a model 13 times smaller beating a much larger competitor:

But here's the caveat you won't find in the headlines: on coding benchmarks, GPT-OSS-120B still wins by a wide margin. LiveCodeBench: 82.7 vs 65.6. The "9B beats 120B" narrative is accurate for knowledge and reasoning — it's misleading if you're primarily looking for a code model. For coding, the 4B is actually more popular in the community: it's stable, consistent, with no performance drops on classification, code fixing, and summarization tasks.

The 35B-A3B pulls off something even more surprising. Despite activating only 3B parameters per token, it beats the previous-generation Qwen3-235B-A22B on core benchmarks. Community speed tests show it hitting 196 tok/s on an RTX 4090 and 60-70 tok/s on an M4 Max via MLX. The Artificial Analysis Intelligence Index rates it at 37 — more than double the median score of 15 for its class.

Qwen3.5-Max-Preview: The API Dark Horse

Alibaba's closed-source Qwen3.5-Max-Preview debuted on LMArena on March 19, 2026. It ranks 10th on the Expert leaderboard with a score of 1498, surpassing GPT-5.4. No public API yet — the pattern from previous releases suggests 2-3 months before general availability.

One broader caveat worth mentioning: AI researcher Nathan Lambert has noted that while Qwen 3.5 models are "legitimately fantastic," the benchmark-first development approach raises questions about real-world generalization. The models score extraordinarily well on structured evaluations — whether that translates equally to messy, real-world tasks is something the community is still figuring out.

How the Hybrid Architecture Works

You don't need to understand the architecture to use Qwen 3.5. But if you're wondering why it's so much faster than Qwen 3 at long contexts, here's the short version.

Standard transformers use quadratic attention — processing cost grows with the square of context length. Qwen 3.5 replaces 75% of its attention layers with Gated DeltaNet, a linear attention mechanism. The remaining 25% use traditional gated attention. This 3:1 ratio (three DeltaNet layers, one full attention layer) gives the model linear scaling for most of the computation while preserving full attention where it matters most.

The practical result: 8.6x faster decoding at 32K tokens and 19x faster at 256K tokens compared to Qwen3-Max. That's not a benchmark artifact — it's a fundamental architectural advantage that shows up in every deployment scenario from local inference to API serving.

All eight models share this hybrid backbone. They also share a 248,320-token vocabulary (up from 152K in Qwen 3), FP8 native precision that cuts activation memory by roughly 50%, and support for 201 languages. The MoE models (397B, 122B, 35B) add expert routing on top — the 397B runs 512 total experts with 11 active per token, while the 35B uses 256 experts with 9 active.

Multimodal: Every Model Sees Images and Video

Previous Qwen generations separated text and vision into different model variants. Qwen 3.5 merges them — every single model from 0.8B to 397B handles text, images, and video through early fusion. No adapter, no separate checkpoint, no "VL" suffix to hunt for.

On document understanding (OmniDocBench1.5), the 397B scores 90.8 — the highest of any model tested, including GPT-5.2 and Gemini 3 Pro. It handles charts, tables, handwritten notes, and multi-page PDFs. On MathVision (multimodal math reasoning), it scores 88.6, beating GPT-5.2's 83.0.

Video input works up to 2 hours in length. Community testers fed it wildlife footage and got accurate animal counts, species identification, and location guesses. The practical use cases range from code generation from wireframes (hand-drawn sketch to functional HTML/CSS) to medical imaging analysis, where testers report structured diagnostic outputs across radiology, pathology, and dermatology — all from a single prompt. For image generation rather than understanding, see Qwen-Image-2.0.

Agentic Capabilities: Terminal-Bench, Browser, Mobile

The 397B leads every agent-focused benchmark. BrowseComp (browser automation): 69.0, beating GPT-5.2 and Claude Opus. NOVA-63 (general agent tasks): 59.1, top of the field. AndroidWorld (mobile app control): 66.8 — a benchmark where competitors haven't even published scores yet.

The Terminal-Bench 2.0 jump tells the real story. Qwen3-Max-Thinking scored 22.5. The Qwen3.5-397B scores 52.5. That's a 2.3x improvement in one generation on a benchmark that measures real terminal interaction — running commands, debugging errors, managing files. It also powers Qwen Code, Alibaba's CLI for delegating coding tasks through natural language.

The model supports native function calling, structured JSON output, and tool use through an OpenAI-compatible API. For teams building AI agents that interact with browsers, mobile apps, or development environments, the combination of strong agentic scores and Apache 2.0 licensing makes it a practical choice without vendor lock-in.

API Access & Pricing

Qwen3.5-Plus is the production API, available through Alibaba Cloud's Model Studio. It's based on the 397B architecture with a 1M context window and built-in tool integration.

That's roughly 70% cheaper than GPT-5 series API calls. Batch mode gives another 50% off for async processing. Thinking mode costs the same as standard — no surcharge. VentureBeat reported that Qwen3.5-Plus responds in 1/6th the time of Claude Sonnet 4.6, making it competitive on both cost and latency.

Quick Start (Python)

from openai import OpenAI

client = OpenAI(
    api_key="YOUR_DASHSCOPE_API_KEY",
    base_url="https://dashscope-intl.aliyuncs.com/compatible-mode/v1"
)

response = client.chat.completions.create(
    model="qwen3.5-plus-2026-02-15",
    messages=[
        {"role": "user", "content": "Explain quantum entanglement simply."}
    ],
    extra_body={"enable_thinking": True}
)

print(response.choices[0].message.content)

The API is OpenAI-compatible — swap the base URL and key in any existing OpenAI SDK integration. It supports multimodal input (images, video), structured JSON output, and function calling. Free testing is available on chat.qwen.ai with rate limits.

Real-World Performance: What the Community Reports

Official benchmarks tell one story. What happens on actual GPUs in actual homes tells another. Here's what r/LocalLLaMA users, Unsloth, and independent testers have found.

Speed by GPU (Measured, Not Claimed)

The 35B-A3B vs 27B numbers highlight the MoE advantage clearly. Both fit on a 24GB card, but the MoE model runs 3-5x faster because it activates fewer parameters. The trade-off: several r/LocalLLaMA users note the 35B-A3B can get "repetitive" in creative prose, while the 27B produces more varied writing. Pick based on your workload.

Thinking Mode: What You Need to Know

Qwen 3.5 does not support the /think and /nothink toggles from Qwen 3 / QwQ. Instead, thinking is controlled via the API parameter enable_thinking. It's on by default for the larger models (27B, 35B, 122B, 397B) and off by default for smaller ones (0.8B, 2B, 4B, 9B). One critical tip: never use greedy decoding — output quality degrades noticeably.

Recommended Sampling Parameters

Fine-Tuning Notes

Unsloth recommends bf16 LoRA for Qwen 3.5 fine-tuning. QLoRA (4-bit) is not recommended — precision issues cause quality degradation. VRAM requirements: 9B needs ~22GB, 27B needs ~56GB, 35B-A3B needs ~74GB. If you downloaded MXFP4 quants from Unsloth before February 27, re-download — those were retired due to quality concerns.

Full Technical Specifications

Reference table for the technically curious. All models share the hybrid GDN + Attention architecture (3:1 ratio), 248,320-token vocabulary, 262K native context (1M via YaRN), native FP8 precision, and Apache 2.0 licensing.

What Changed from Qwen 3

Frequently Asked Questions