Qwen3.8-27B released as open weights under Apache 2.0

What stands out isn't the scores but the size. At 4-bit precision it shrinks to 17.9GB — fitting on a single RTX 4090 or 5090, or a Mac with 24GB of unified memory. Considering that Qwen3.8-Max, which grabbed headlines two weeks ago, has 2.4 trillion parameters and requires multiple H100s, this is the version people can actually get their hands on.

Why does a 27B model score like this?

The architecture is unusual. Its 64 layers are organized into 4-layer blocks repeated 16 times, and each block consists of "3 Gated DeltaNet layers + 1 Gated Attention layer." Three are linear-attention variants, and only the fourth is the full attention mechanism we're familiar with.

Think of it like a meeting. Three participants summarize the minutes and carry that summary around in their heads, while only the fourth person digs through the entire original file cabinet when needed. Since only one out of four is digging through the file cabinet, memory doesn't explode even when fed 260,000 tokens.

Hidden dimension is 5,120, FFN intermediate dimension is 17,408, and there are 248,320 token embeddings. Gated Attention uses only 24 Q heads and 4 KV heads, keeping the cache light. On top of this sits a vision encoder that reads images and video together.

It went head-to-head with Opus 4.6 Max in the official chart

The comparison table Qwen included directly in the model card places the predecessor Qwen3.6-27B, the higher-tier API model Qwen3.7-Plus, and Claude Opus 4.6 Max side by side. The fact that a 27B model appears in the same table as a frontier closed model is itself the message of this release. Below is the original table Qwen published alongside the announcement.

Item	Qwen3.8-27B	Qwen3.6-27B	Qwen3.7-Plus	Opus 4.6 Max
Agentic coding (SWE-bench Pro)	61.7	53.5	57.6	53.4
Agentic coding (DeepSWE 1.1)	42.2	13.3	14.2	—
Terminal coding (Terminal Bench 2.1)	73.0	63.4	64.0	78.2
Long-horizon office work (CoWorkBench)	70.7	61.0	65.1	68.2
Instruction following (IFBench)	79.5	69.1	79.1	62.5
Scientific reasoning (GPQA Diamond)	89.2	87.8	90.3	91.3
Comprehensive hard reasoning (HLE)	30.8	24.0	34.7	40.0

The multimodal gap is even larger. Computer control (OSWorld-Verified) is 84.3 vs. 72.7, and mobile control (AndroidWorld) is 81.9 vs. 62.0.

That said, this is a vendor-produced table. QwenSWEBench (79.0), included alongside the others, is a benchmark Qwen built itself, and the comparison target Opus 4.6 Max is one generation behind, following Anthropic's release of Opus 5 on July 24. The gap in vision-related items also largely reflects comparing a model with a vision encoder attached against a text-centric model on the same scale.

Still, something remains. It still lags on the hardest reasoning and terminal coding tasks, but in practical coding and office automation, a 27B model has landed on the same tier as the frontier.

Serving it — commands and the 1-million-token context

The model card recommends vLLM, SGLang, and TokenSpeed as the stack. The commands below are all it takes.

# vLLM (the safest default)
pip install vllm
vllm serve Qwen/Qwen3.8-27B

# SGLang — faster for workloads with a fixed system prompt
python3 -m sglang.launch_server \
    --model-path Qwen/Qwen3.8-27B --host 0.0.0.0 --port 30000

# If VRAM is tight, the official FP8 variant (block-128 fine-grained quantization)
vllm serve "Qwen/Qwen3.8-27B-FP8"

# One-line Docker
docker model run hf.co/Qwen/Qwen3.8-27B

To exceed 262,144 tokens, add YaRN scaling to config.json. Below is the full configuration from the model card.

{
    "rope_parameters": {
        "mrope_interleaved": true,
        "mrope_section": [11, 11, 10],
        "rope_type": "yarn",
        "rope_theta": 10000000,
        "partial_rotary_factor": 0.25,
        "factor": 4.0,
        "original_max_position_embeddings": 262144
    }
}

VLLM_ALLOW_LONG_MAX_MODEL_LEN=1 vllm serve Qwen/Qwen3.8-27B --max-model-len 1000000

SGLANG_ALLOW_OVERWRITE_LONGER_CONTEXT_LEN=1 python3 -m sglang.launch_server \
    --model-path Qwen/Qwen3.8-27B --context-length 1000000

Running it on a laptop — measured sizes for 21 GGUF variants

The Unsloth GGUF repository has 21 files uploaded. Below are the actual file sizes for all of them. It's like lowering the quality slider when saving a photo as JPEG — the lower you go, the lighter it gets, and past a certain point the degradation becomes noticeable.

File	Size	File	Size
UD-IQ2_XXS	9.01 GB	Q4_K_M	17.1 GB
UD-IQ2_M	10.3 GB	Q4_1	17.5 GB
UD-Q2_K_XL	10.7 GB	UD-Q4_K_XL	17.9 GB
UD-IQ3_XXS	11.9 GB	Q5_K_S	19.3 GB
Q3_K_S	12.6 GB	Q5_K_M	19.8 GB
UD-Q3_K_XL	13.4 GB	UD-Q5_K_XL	20.2 GB
Q3_K_M	13.8 GB	Q6_K	22.9 GB
IQ4_XS	15.7 GB	UD-Q6_K_XL	25.9 GB
Q4_0	16.1 GB	Q8_0	29 GB
Q4_K_S	16.1 GB	UD-Q8_K_XL	31.5 GB
IQ4_NL	16.3 GB	BF16 (original)	56 GB

./llama.cpp/llama-cli \
    --model unsloth/Qwen3.8-27B-GGUF/Qwen3.8-27B-UD-Q4_K_XL.gguf \
    --temp 1.0 --top-p 0.95 --top-k 20 --min-p 0.0

One catch: shrinking the weights doesn't shrink the KV cache. Even if you compress the model down to 15GB at 4-bit precision, setting a long context can add over 10GB of cache on top of that separately. It's like folding a document in half — the desk it's spread out on stays the same size. Since most stacks support FP8 quantization for the KV cache, enabling that option should be the first step.

Thinking mode switch and recommended sampling

Thinking mode is the default. It writes out reasoning before answering, and can be turned off per request. reasoning_effort (xhigh/medium/low) controls depth, and preserve_thinking keeps the reasoning block across multiple turns.

completion = client.chat.completions.create(
    model="Qwen/Qwen3.8-27B", messages=messages,
    extra_body={"chat_template_kwargs": {
        "enable_thinking": True, "preserve_thinking": True}},
    reasoning_effort="xhigh",
)

# Turning off thinking mode for direct answers only
chat_response = client.chat.completions.create(
    model="Qwen/Qwen3.8-27B", messages=messages,
    temperature=0.7, top_p=0.8, presence_penalty=1.5,
    extra_body={"top_k": 20,
        "chat_template_kwargs": {"enable_thinking": False}},
)

Recommended sampling values differ by mode. Using the defaults as-is causes answers to become scattered in thinking mode.

Parameter	Thinking mode	Instruct mode
temperature	1.0	0.7
top_p	0.95	0.80
top_k	20	20
min_p	0.0	0.0
presence_penalty	0.0	1.5

Images and video go through the same endpoint. You simply add {"type": "image_url", ...} or {"type": "video_url", ...} to content, and the model card states it handles even hour-long videos through frame sampling.

Summary at a glance

Item	Value
Repository	Qwen/Qwen3.8-27B · FP8: Qwen/Qwen3.8-27B-FP8
License	Apache 2.0 (no user-count limits or royalties)
Architecture	27B dense + vision encoder · 64 layers · hidden 5,120
Attention	Gated DeltaNet 3 : Gated Attention 1, repeated
Context	262,144 default / 1 million with YaRN
Minimum to run	4-bit GGUF, 17.9GB — 24GB-class GPU or Mac
Default mode	Thinking mode ON (toggled via enable_thinking)

Editor's view

If you tried plugging a 27B-class open model into real work this time last year, the conclusion was always the same. It was usable for summarizing, classifying, and extracting, but the moment it had to make its own judgment calls while calling tools repeatedly, it would drift off course by roughly the third step. That's why the division of labor "local models for preprocessing, judgment left to the API" made natural sense.

What caught my eye in this table wasn't SWE-bench Pro or GPQA, but CoWorkBench at 70.7. This is a long-horizon task that requires continuously holding onto a goal, using tools, and maintaining trajectory — and here, the 27B model beat Opus 4.6 Max (68.2). That's a different kind of story than a single-turn Q&A score; it means the gap has narrowed in staying power over time, not just one-shot competence.

That doesn't mean canceling your API subscription. On the hardest questions, the frontier model still wins. But most of the work companies actually run doesn't reach that level of difficulty. Organizing internal documents, repetitive code fixes, screen-based click automation — this entire tier has now shifted to "something that can be finished entirely on my own server."

There are three implications for teams in Korea. First, organizations that had halted AI adoption due to data export restrictions now have an actual option. Being Apache 2.0 means no user-count conditions and no separate negotiations. In other words, no legal review needed.

Second, the budget math changes. If a single 24GB card is the baseline, team-level experimentation drops into a price range that clears approval with a single expense request. The point where local-model reviews kept stalling was always "so how many servers do we need to buy."

Third, even so, it's safer not to use 4-bit precision as-is for agentic work. Quantization loss doesn't show up in a single answer, but it accumulates and erupts over a twenty-step task. Since Q8_0 comes to 29GB in the table above, if you're seriously planning to run agents, setting 32GB or more as the baseline is the realistic call.

One last thing. Qwen3.8-Max grabbed the headlines with its 2.4 trillion parameters, but what has actually moved the ecosystem has always been sizes people can hold in their hands. Every explosion in fine-tunes and derivative models over the past two years happened at that scale. The file name most talked about in Korean communities this weekend won't be the 2.4 trillion-parameter model — it'll be a single 17.9GB GGUF file.