Benchmark-tested across coding (HumanEval), math (GSM8K), and reasoning (MMLU) tasks, this 27B-parameter model from Alibaba Cloud's Tongyi Lab delivers performance rivaling 70B-class systems, with 3–5× faster token throughput. Integrated via a low-latency API endpoint, it's the go-to choice for applications where every millisecond and every token budget matters — from real-time translation engines to autonomous decision agents.
Benchmark results are only useful when they correlate with real tasks. Qwen's team shaped this release around direct community feedback, targeting agentic coding workflows rather than chasing leaderboard novelty. Here's how it stacks up.
Most models at this size either sacrifice depth for speed or pay the quadratic cost of full self-attention at every layer. Qwen3.6-27B takes a different approach — a layered hybrid that keeps computation linear for most of the stack, reserving full attention for where it counts.
Three out of every four sublayers use Gated DeltaNet — a linear attention mechanism with O(n) complexity instead of the O(n²) scaling of standard self-attention. This is what makes 262K-token contexts tractable without ballooning memory requirements.
The model's hidden layout repeats a specific pattern across 64 layers: three Gated DeltaNet → FFN blocks followed by one Gated Attention → FFN block. This 3:1 ratio is deliberate — it balances efficiency with expressiveness throughout the depth of the network.
The attention layers use asymmetric query and key/value head configurations, reducing memory bandwidth at inference time without losing the representational capacity that matters for complex reasoning tasks.
Qwen3.6-27B is natively multimodal — it processes text, images, and video through a built-in vision encoder trained end-to-end alongside the language model, not bolted on afterward.
| Specification | Details |
|---|---|
| Parameters | 27 Billion |
| Architecture | Dense Causal LM + Vision |
| Layers | 64 |
| Hidden Dim | 5,120 |
| FFN Intermediate | 17,408 |
| Token Vocab | 248,320 (padded) |
| Context (native) | 262,144 tokens |
| Context (extended) | 1,010,000 tokens |
| Quantized Variant | FP8 (block size 128) |
| Local Footprint | ~18 GB (GGUF quant) |
| Modalities | Text · Image · Video |
| License | Apache 2.0 |
| Frameworks | vLLM · SGLang · HF · KTransformers |
Every major model release claims to be better. Here are the specific things Qwen3.6-27B does differently and why they matter for people building real systems.
Qwen3.6-27B introduces a mechanism that retains reasoning traces across conversation turns. In multi-step agent workflows, this means the model doesn't re-derive conclusions it already worked through, reducing redundant token generation and improving KV cache efficiency significantly.
The model is specifically tuned for frontend workflows and repository-level reasoning, navigating large codebases, editing across multiple files, and producing runnable output. Its QwenWebBench score of 1,487 is a 39% jump over Qwen3.5-27B, spanning web design, SVG, data visualization, 3D, and animation tasks.
Text, images, and video are first-class inputs. The vision encoder is trained alongside the language model rather than glued on, which matters for tasks that require genuine cross-modal reasoning rather than just image captioning.
The model supports both standard and extended reasoning modes. In thinking mode, reasoning traces can be preserved across turns. Developers can toggle enable_thinking at the API level to control when deep chain-of-thought is activated versus when fast inference is preferred.
Qwen3.6-27B supports structured tool calling out of the box, compatible with the OpenAI tool-call format. It integrates natively with Model Context Protocol (MCP) servers for filesystem access, web browsing, and custom tool orchestration in agentic pipelines.
With SWE-bench Verified at 77.2%, this is one of the strongest open models available for building agents that write, edit, and debug code across real repositories. Terminal-Bench performance at 59.3% means it can operate in shell environments reliably over long sessions.
QwenWebBench covers web design, games, SVGs, data visualizations, and 3D. A score of 1,487, up from 1,068 for the previous 27B model, represents a meaningful jump in the quality of generated UI code, particularly for complex interactive layouts.
An 18GB GGUF footprint on a single GPU with Apache 2.0 licensing means organizations that can't send data to external APIs now have a frontier-adjacent option they can host entirely inside their own infrastructure.
The 262K native context window, extensible to over one million tokens, makes it practical for tasks like codebase-wide reasoning, legal document review, long-form research synthesis, and processing large structured datasets in a single pass.
The built-in vision encoder means the model can process PDFs with embedded images, annotated diagrams, screenshots, and video frames alongside text — useful for technical documentation parsing and visual QA workflows without needing a separate vision model.
Apache 2.0 means no commercial restrictions, and the dense architecture (no MoE routing complexity) is significantly easier to fine-tune than sparse models of similar capability. Pre-training on ~36 trillion tokens gives a strong general knowledge foundation to build on.
The short answer is that raw parameter count stopped being the main predictor of performance some time ago. Qwen3.6-27B benefits from a newer training recipe — higher-quality data, stronger reinforcement learning from human feedback, and an architecture optimized specifically for agentic coding tasks. The 397B model it outperforms is a mixture-of-experts design from an earlier generation, which means both the training and the evaluation criteria have evolved. That said, the 27B model only outperforms on the specific coding benchmarks listed — for broader general knowledge or other capability areas, larger models still tend to perform better.
The native context window is 262,144 tokens (~200K words). Beyond that, the model can be configured to extend to approximately 1,010,000 tokens using position interpolation techniques — but this extended range requires additional setup and performance can degrade on tasks requiring very precise retrieval from the far ends of a very long context. For most practical use cases, the native 262K window is sufficient and more reliable.
In standard mode, the model generates responses directly without explicit chain-of-thought reasoning traces. This is faster and cheaper, suitable for most conversational or straightforward coding tasks. In thinking mode (enabled via enable_thinking: True), the model works through a reasoning process before producing its final answer. This increases output token count and latency, but substantially improves accuracy on complex multi-step problems. Thinking Preservation extends this by caching those reasoning traces across turns.
Measured on the AI/ML API gateway across live traffic. Figures are medians unless stated. Last updated 2026-10-12.
Qwen3.6 27B is documented as suited to agentic coding and repository-level reasoning, including building coding assistants and multi-step software workflows.
It is also suited to multimodal reasoning over text, images, and video, including document understanding and visual question answering.
The model is documented for frontend generation and UI-focused workflows, where it can inspect screenshots or other visual inputs and help diagnose or fix interface issues.
It is additionally suited to long-context understanding, including work over large codebases and other extended multimodal inputs.
import requests r = requests.post( "https://api.aimlapi.com/v1/chat/completions", headers={"Authorization": "Bearer " + AIMLAPI_KEY}, json={ "model": "alibaba/qwen3.6-27b", "messages": [ { "role": "user", "content": "Hello!" } ] }, ) print(r.json())
const r = await fetch("https://api.aimlapi.com/v1/chat/completions", { method: "POST", headers: { Authorization: `Bearer ${process.env.AIMLAPI_KEY}`, "Content-Type": "application/json", }, body: JSON.stringify({ "model": "alibaba/qwen3.6-27b", "messages": [ { "role": "user", "content": "Hello!" } ] }), }); console.log(await r.json());
curl -X POST https://api.aimlapi.com/v1/chat/completions \ -H "Authorization: Bearer $AIMLAPI_KEY" \ -H "Content-Type: application/json" \ -d '{"model":"alibaba/qwen3.6-27b","messages":[{"role":"user","content":"Hello!"}]}'
OpenAI-compatible — swap the base URL and it works with your existing SDK.
| Type | Price |
|---|---|
| Input | |
| Output | |
| Benchmark | Score | What it measures | Source | Retrieved |
|---|---|---|---|---|
| Intelligence | 21.9 | Composite score across standardised reasoning, knowledge and problem-solving evaluations, measured independently by Artificial Analysis | Source | September 12, 2026 |
| Coding | 53.7 | Composite score across standardised coding evaluations, measured independently by Artificial Analysis | Source | September 12, 2026 |
| SWE-bench Verified | 77.2 | Resolving verified real GitHub issues | Source | September 21, 2026 |
| MMLU-Pro | 86.2 | Multi-discipline knowledge + reasoning (harder MMLU) | Source | September 21, 2026 |
| GPQA Diamond | 87.8 | Google-proof graduate science questions (hardest subset) | Source | September 21, 2026 |
| Model | Input | Output | Context | Best for |
|---|---|---|---|---|
Qwen 3.6 27B This page | Reasoning + agents | |||
| Reasoning + agents | ||||
| Balanced coding + agents | ||||
| Long-context, multimodal & agentic workflows | ||||
| Reasoning + agents |
Qwen 3.6 27B has a 256,000 tokens context window and can return up to 252,000 tokens.
Qwen 3.6 27B takes image, text as input and returns text.
Use alibaba/qwen3.6-27b as the model id. Requests go to https://api.aimlapi.com/v1/chat/completions.
Qwen 3.6 27B became available on April 23, 2026.
Qwen 3.6 27B is priced at input $0.78 / 1M tokens, output $4.68 / 1M tokens.
Yes, Qwen 3.6 27B can stream responses as they are generated.
Yes, Qwen 3.6 27B accepts image input alongside text.
Qwen 3.6 27B was built by Alibaba Cloud.
