Using Qwen3.6-27B on Chutes

Qwen3.6-27B is the first open-weight model of the Qwen3.6 generation: a dense 27B vision-language model built for agentic coding, with a 262K-token native context. On Chutes it runs from FP8 weights inside a Trusted Execution Environment (TEE) with DFlash speculative decoding, behind an OpenAI-compatible API.

Overview

Released by the Qwen team in April 2026 under Apache-2.0, Qwen3.6-27B prioritizes stability and real-world coding utility. Its 64 layers use a hybrid-attention layout: 16 repeating blocks of three Gated DeltaNet (linear attention) layers plus one Gated Attention (full attention) layer, each followed by an FFN. Gated DeltaNet runs 48 value heads and 16 QK heads at head dim 128; the full-attention layers use 24 query heads and 4 KV heads at head dim 256. The design keeps long-context memory cost low while preserving full attention periodically, and the model is trained with multi-step MTP (multi-token prediction) that serving stacks can use for speculative decoding. A vision encoder makes it image-text-to-text, with video input also demonstrated in the model card. Headline card numbers: 77.2 SWE-bench Verified, 59.3 Terminal-Bench 2.0, and 48.2 SkillsBench, competitive with much larger models.

Model specifications

Quick start

Base URL https://llm.chutes.ai/v1, model name Qwen/Qwen3.6-27B-TEE, Bearer auth with your Chutes API key.

curl -X POST "https://llm.chutes.ai/v1/chat/completions" \
  -H "Authorization: Bearer $CHUTES_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "Qwen/Qwen3.6-27B-TEE",
    "messages": [{"role": "user", "content": "Refactor this function to be tail-recursive."}],
    "stream": true,
    "max_tokens": 4096,
    "temperature": 0.6
  }'

import os
from openai import OpenAI

client = OpenAI(base_url="https://llm.chutes.ai/v1", api_key=os.environ["CHUTES_API_KEY"])

resp = client.chat.completions.create(
    model="Qwen/Qwen3.6-27B-TEE",
    messages=[{"role": "user", "content": "Refactor this function to be tail-recursive."}],
    max_tokens=4096,
    temperature=0.6,
)
print(resp.choices[0].message.content)

const res = await fetch("https://llm.chutes.ai/v1/chat/completions", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.CHUTES_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    model: "Qwen/Qwen3.6-27B-TEE",
    messages: [{ role: "user", content: "Refactor this function to be tail-recursive." }],
    max_tokens: 4096,
    temperature: 0.6,
  }),
});
const data = await res.json();
console.log(data.choices[0].message.content);

Parameters and tuning

Chute request fields and defaults (from the live llms.txt): max_tokens 1024, temperature 0.7, seed 42, streaming on both /v1/chat/completions and /v1/completions; the completions endpoint also accepts vLLM-style fields (top_p, top_k, min_p, presence_penalty, repetition_penalty).

The model card's recommended sampling depends on mode. General thinking-mode tasks: temperature 1.0, top_p 0.95, top_k 20, min_p 0 (this matches generation_config.json). Precise coding tasks such as WebDev: temperature 0.6, same top_p/top_k. Instruct (non-thinking) mode: temperature 0.7, top_p 0.80, top_k 20, presence_penalty 1.5. The model thinks by default and emits <think>...</think> before the answer, so budget max_tokens well above the chute's 1024 default for nontrivial tasks; the card's own examples use limits up to 81,920.

What it's best at

Agentic coding is the release's explicit focus: SWE-bench Verified 77.2, SWE-bench Pro 53.5, SWE-bench Multilingual 71.3, and Terminal-Bench 2.0 59.3 per the model card, with improved fluency on frontend workflows and repository-level reasoning. The 262K native context suits whole-repo and long-document tasks, and the thinking-preservation option carries reasoning across turns in iterative agent loops, cutting re-reasoning overhead. As a vision-language model it also handles image and video understanding, and the card recommends Qwen-Agent for tool-calling workloads.

It is less suited to hard low-latency paths with thinking enabled (reasoning tokens lengthen every reply), does not accept audio input, and being dense, it lacks the compute-per-token savings of MoE models of similar total size.

How Chutes serves this model

This chute serves the FP8 build of Qwen3.6-27B inside a Trusted Execution Environment, so requests are processed on attested confidential-compute hardware. Generation is accelerated with DFlash speculative decoding, which exploits the model's MTP training; both FP8 and speculative decoding are serving-level optimizations rather than changes to the model. The endpoint lives on the shared OpenAI-compatible gateway with streaming, billed per token. See the model page, the machine-readable llms.txt, and the callable OpenAPI spec.

FAQ

How large is the context window?

262,144 tokens natively, per both config.json and the model card. The card states it is extensible up to 1,010,000 tokens with appropriate serving configuration; treat the native 262K as the dependable planning number.

Is Qwen3.6-27B multimodal?

Yes. It is an image-text-to-text model with a vision encoder, and the model card demonstrates both image and video input through OpenAI-compatible messages. Output is text only.

Does it emit thinking tokens?

By default, yes: responses begin with a <think>...</think> block before the final answer. The card documents an instruct (non-thinking) mode for direct responses, and a new thinking-preservation option that carries reasoning context across turns in agent workflows.

What sampling parameters should I use?

Per the model card: temperature 1.0, top_p 0.95, top_k 20, min_p 0 for general thinking-mode tasks; drop temperature to 0.6 for precise coding work such as WebDev; and temperature 0.7, top_p 0.80, top_k 20 with presence_penalty 1.5 for instruct mode.

How do I call it from the OpenAI SDK?

Set base_url to https://llm.chutes.ai/v1, use your Chutes API key, and pass model Qwen/Qwen3.6-27B-TEE. Chat completions with streaming work as with any OpenAI-compatible endpoint.

What does TEE mean for this chute?

The model runs inside a Trusted Execution Environment: attested confidential-compute hardware, so prompts and outputs are processed in protected memory. It is a serving property; the underlying weights are the Qwen3.6-27B FP8 build.

Can I use it commercially?

Yes. The upstream repository is Apache-2.0 licensed, which allows commercial use, modification, and redistribution. Endpoint usage is billed through your Chutes account, separately from the model license.

How good is it at coding, really?

The model card reports 77.2 on SWE-bench Verified, 53.5 on SWE-bench Pro, 71.3 on SWE-bench Multilingual, and 59.3 on Terminal-Bench 2.0. The release explicitly targets agentic coding, frontend workflows, and repository-level reasoning.

Sources

• Qwen/Qwen3.6-27B on Hugging Face
• config.json and generation_config.json
• Qwen3.6-27B-TEE model page on Chutes
• Live llms.txt for this chute