Qwen3.6-27B-MTP

Updated
24.08.2026
Thinking
Tools
Vision
Run

Qwen3.6-27B-MTP is Qwen3.6-27B served with its Multi-Token Prediction head: the model drafts several tokens per step for faster local generation.

At a glance

  • License: Apache 2.0
  • Parameters: 27.8B dense, same weights as Qwen3.6-27B
  • Context length: 262,144 tokens, extensible to 1,010,000
  • Modalities: text and image input
  • Minimum hardware: 11 GB GGUF at UD-IQ2_M, 17.1 GB at Q4_K_M

What is Qwen3.6-27B-MTP?

Qwen3.6-27B-MTP is Qwen3.6-27B running with its Multi-Token Prediction head active. Qwen trained the MTP head with multiple steps and documents it on the model card, so a serving stack can draft several tokens per forward pass and verify them in one go. That is speculative decoding without a separate draft model: the same mechanism we cover in what speculative decoding is, folded into the checkpoint itself.

SpecificationQwen3.6-27B-MTP
Base modelQwen3.6-27B, same weights
Parameters27.8B dense, 64 layers
ArchitectureHybrid attention: Gated DeltaNet + Gated Attention, plus a vision encoder
MTPTrained with multiple steps
Context window262,144 natively, extensible to 1,010,000
Release dateApril 2026, GGUF May 2026
LicenseApache 2.0

What MTP changes

Nothing about quality, everything about speed. With MTP the model drafts a few tokens ahead and the main forward pass verifies each of them, so the output distribution is identical to normal decoding. The win is wall-clock: accepted drafts cost far less than full forward passes. How large the win is depends on the acceptance rate for your workload, which is why coding and structured text tend to benefit most.

Qwen's card gives exact serving commands. In vLLM you pass a speculative config with method qwen3_next_mtp and 2 speculative tokens. In SGLang you launch with speculative-algo NEXTN, 3 speculative steps, top-k 1 and 4 draft tokens. Both commands keep the full 262,144-token context.

Qwen3.6-27B-MTP hardware requirements

Memory needs match Qwen3.6-27B, since the weights are the same. Sizes below are from the Unsloth GGUF repository that carries the MTP tensors:

MemoryBuild to pickFile size
16 GBUD-IQ2_M11.0 GB
24 GBQ4_K_M17.1 GB
32 GBQ6_K22.9 GB
48 GB and upQ8_029.1 GB

The vision projector adds 0.93 GB. When two builds both fit, take the larger one.

How to run Qwen3.6-27B-MTP in Atomic Chat

Atomic Chat is a free local app for macOS, Windows and Linux. It includes a Hugging Face model browser and a built-in chat, with no manual llama.cpp build required.

  1. Download Atomic Chat for your platform and open it.
  2. Search for Qwen3.6-27B in the model browser and open Download Options.
  3. Pick the build that fits your memory and start a chat.

The MTP tensors ride along in the GGUF; the vLLM and SGLang commands above are the vendor's route to speculative serving on a GPU box. See the rest of the lineup on the Qwen family page.

Qwen3.6-27B-MTP license

The weights are released under Apache 2.0, same as Qwen3.6-27B. That permits commercial use, modification and redistribution with no royalties.

Get the weights from Hugging Face

# GGUF with the MTP tensors, published by Unsloth:
huggingface-cli download unsloth/Qwen3.6-27B-MTP-GGUF --include "*Q4_K_M*"
# original weights:
huggingface-cli download Qwen/Qwen3.6-27B
curl http://localhost:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "Qwen3.6-27B",
    "messages": [{"role": "user", "content": "Refactor this function and explain the change."}]
  }'
# Qwen's recommended MTP serving command (vLLM):
# vllm serve Qwen/Qwen3.6-27B --port 8000 \
#   --reasoning-parser qwen3 \
#   --speculative-config '{"method":"qwen3_next_mtp","num_speculative_tokens":2}'
from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="local")
res = client.chat.completions.create(
    model="Qwen/Qwen3.6-27B",
    messages=[{"role": "user", "content": "Summarise this repository layout."}],
)
print(res.choices[0].message.content)
import OpenAI from "openai";

const client = new OpenAI({ baseURL: "http://localhost:8000/v1", apiKey: "local" });
const res = await client.chat.completions.create({
  model: "Qwen/Qwen3.6-27B",
  messages: [{ role: "user", content: "Write a Python function that parses a GGUF header." }],
});
console.log(res.choices[0].message.content);
Desktop
macOS
(M1 or better)
Download
Windows
(x64)
Download
Linux
(x86_64)
Download

Frequently asked questions

It is Qwen3.6-27B served with its Multi-Token Prediction head active. Qwen trained the MTP head with multiple steps, so a serving stack can draft several tokens per forward pass and verify them in one go, which is speculative decoding without a separate draft model. The weights, quality and 262,144-token context are the same as Qwen3.6-27B.

Qwen's model card gives ready commands for both major stacks. In vLLM, pass a speculative config with method qwen3_next_mtp and num_speculative_tokens 2. In SGLang, launch with speculative-algo NEXTN, 3 speculative steps and 4 draft tokens. llama.cpp builds with the MTP tensors are published as GGUF.

No. Speculative decoding drafts tokens ahead and the main model verifies every one of them, so the output distribution matches running the model normally. The gain is generation speed, and the speedup depends on how many drafted tokens get accepted for your workload.

The same as Qwen3.6-27B. A Q4_K_M GGUF is 17.1 GB, so a 24 GB GPU or a 32 GB Mac runs it comfortably; a UD-IQ2_M build at 11 GB fits 16 GB machines. The vision projector adds about 0.9 GB.