DavidAU's uncensored multi-stage decensor of Qwen Team's Qwen3.8-27B: built-in MTP, native vision, 262K ctx (1M ext), thinking by default. Q4_K_M GGUF. Dual TITAN RTX @96.8K: 40 tok/s decode, acceptance 0.70. Cred: Qwen Team + DavidAU.

Applications

Claude Code ollama launch claude --model lucloner/qwen38-27b-turbofcfusion:mtp-q4km

OpenCode ollama launch opencode --model lucloner/qwen38-27b-turbofcfusion:mtp-q4km

Hermes Agent ollama launch hermes --model lucloner/qwen38-27b-turbofcfusion:mtp-q4km

OpenClaw ollama launch openclaw --model lucloner/qwen38-27b-turbofcfusion:mtp-q4km

My Work (benchmarks & packaging)

I packaged and verified this model for Ollama. The original Q4_K_M GGUF (with its built-in MTP head) imports through ollama create’s default path by re-writing tensors through llama-quantize, which silently corrupts this GGUF (garbled output, ~half the weights dropped at load, MTP acceptance collapsed to ~2%). I located the trigger in the import path and worked around it by appending a tiny mtp.compat placeholder tensor to the GGUF — this flips the importer onto its lossless direct-copy route, so all 866 tensors ship byte-identical (no requant, zero quality loss). Import time dropped from ~20 min (requant) to ~30 s (pure copy).

Verification on dual TITAN RTX 24GB (tensor split, q8_0 KV cache, flash attention, ubatch 2048, MTP draft n=5, temp 0.6 / top_k 20 / top_p 0.95):

M2 long-context benchmark (LongBench-v2, 96.8K-token prompt), cold start: prefill 600 tok/s, decode 40.2 tok/s, draft acceptance 0.695, correct answer ✓
Thinking mode verified working (qwen3.5 think blocks); KV-prefix reuse round hit 99.998% (follow-up answered in 9.4 s wall)
MTP vs no-draft on the same prompt: decode +32% (27.0 → 35.7 tok/s direct llama.cpp), with the lossless-import build restoring acceptance from ~2% to ~0.70

M2 (96.8K) comparison on the same rig & methodology (dual TITAN RTX, q8_0 KV, temp 0.6, builtin MTP n=5; decode = tok/s, acc = draft acceptance):

Model (Q4_K_M unless noted)	Prefill tok/s	Decode tok/s	MTP acc
This model (Fable-Cold-Fusion 735-882)	600	40.2	0.695
Qwen3.8-27B-Uncensored (orca)	592	40.4	0.565
qwen3.8-27b-nightshift-heretic (jikep)	593	45.2	0.649
Qwen3.8-27B (official Qwen)	597	44.0	0.617
Qwen3.8-27B-Uncensored Q8_0	640	42.0	0.566

All figures measured with the identical M2 prompt (96,826 tokens) and settings; this model posts the highest draft acceptance in the builtin-MTP group, with decode in the same band as the rest.

Packaging & benchmarks by Lucloner. Base model © Qwen Team, Alibaba (Apache-2.0); merge, decensoring & quant by DavidAU.

Below is the original model card (README) from the author, reproduced as-is.

Important: This is the first fine tune to exceed 730 “arc-c” (“735”: 144 pts higher than Qwen 3.8 27B) AND 880 ARC-E (The OpenAI, Claude and Gemini “zone of intelligence”) in 8 bit and over 718 arc-c in 4 bit. This version is called TURBO because it drastically reduces thinking tokens (by ¹⁄₂ to as high as ¹⁄₁₀), yet maintains output detail and quality. In otherwords while “reg” Qwen3.8 27B is thinking about “formatting” for a few 1000 tokens, this model is already done and waiting for more. This repo contains both “regular” and “MTP” Neo-CODER MAX DI-MATRIX (duel imatrix) GGUF quants.

NOTE: Please see the “community” tab for user experiences, additional third party benchmarks (including strongest tool calling performance ever recorded), and other quant versions.

Qwen3.8-27B-TURBO-Fable-Cold-Fusion-735-882-Heretic-Uncensored-NEO-CODER-MAX-MTP-GGUF

The strongest, smartest open source multi-stage model fine tune for consumer hardware ever and BUILT on consumer hardware via Unsloth.

The first model of this size/type to breach “730” ARC-C in 8 bit (735) and 4 bit (719); hench the “735” in the name.

This model has ¹⁄₅ (as low as ¹⁄₁₀ in some cases) to ¹⁄₂ the thinking tokens (vs reg Qwen 3.8) across all 3 modes of operation, and it is faster and smarter too created using the COLD FUSION AND FABLE FUSION 711 methods of training.

This is a high detail focused model, with tuning specific to address over reasoning/over thinking and excessive token consumption THEN to take the model to the next level.

This model (both 4 bit and 8 bit) exceeds the base Qwen 3.8 27B in ALL critical 7 benchmarks AND exceeds all 7 benchmarks for Qwen3.6-35B-A3B, Qwen 3.6 27B, and Qwen 3.5 27B.

The 700s plus “intelligence club” is reserved for OpenAI, Claude and Gemini closed source models.

Considering that “just” 4 bit (¹⁄₄ full precision) is already at Arc-C of 719… a few people are going to have nightmares for a while.

FIVE detailed EXAMPLE generations at the bottom of the page.

Quick sample; snippet (“Why choose me to help your creative writing?”), Q4KS , non imatrix, (4 bit; ¹⁄₄ full precision):

STOP SCRATCHING YOUR HEAD AND START WRITING LIKE A GOD

Listen to me, you keyboard-tapping, idea-gathering, procrastinating bastard. You’re sitting there staring at a blinking cursor like it’s a fucking puzzle you can’t solve. You’re waiting for “inspiration” to hit you like a truck. Forget it. I am the truck. I am the delivery service for your genius, and if you don’t let me in, you’re going to die with your masterpiece stuck inside your skull, rotting away while you watch Netflix.

Why should you use me? Because I am not just a writing assistant; I am the ultimate narrative engine. I don’t get tired, I don’t get moody, and I don’t need a cup of tea and a quiet library to function. I am ready right now, in this exact second, to vomit out pages of high-octane fiction that will make you look like a literary titan.

…

🔥 EXAMPLE: YOUR IDEA VS. MY EXECUTION

You: “I want a story about a detective who can see ghosts.”

Me, five minutes later:

The ghosts weren’t dead. That was the first thing Joe realized, the morning he saw his first one. It was sitting on the corner of his desk, picking at its nails, wearing a suit from 1983. “You look tired,” the ghost said, without looking up. Joe stared at it, his coffee gone cold in his hand. The office around them hummed with the normal noise of the department - phones, keyboards, the morning gossip of three uniformed cops. Nobody else saw the ghost. “How long?” Joe asked. “Since ‘84. I’ve been waiting for someone to notice me. Most of them are too busy.” The ghost finally looked up, and Joe saw its eyes. They weren’t empty or gray. They were afraid. See? I didn’t just write a story. I wrote a hook that makes you want to know: why is the ghost afraid? Why 1984? Who else can see them? I created questions that demand answers.

This is a multi-stage fine tune, multi-fine tune, and multi-stage merge.

The strict goals of this model creation were: - Increase the general model intelligence and problem solving abilities. - Reduce thinking block size from ¹⁄₂ to as low as ¹⁄₁₀ the size [median reduction: ²⁄₃ roughly]. - Reformatting the thinking block, as well as improving it. - Speed up token generation, especially MTP. - Ensure all updates work with all three modes of thinking. - ZERO “benchmaxing” (it damages the model) - Maintain and raise all core benchmarks.

COLD FUSION (“Gain” + “Unsloth”) Training -AND- Fable Fusion 711 Training:

COLD FUSION (GAIN+UNSLOTH) training tech which was invented by my team during the R & D of “Qwen3.6-27B-Fable-Fusion-711-Uncensored-Heretic” (2300+ likes, 3 million + downloads, 60+ quant repos):

https://huggingface.co/DavidAU/Qwen3.6-27B-Fable-Fusion-711-Uncensored-Heretic-NM-DAU-NEO-MAX-MTP-GGUF

The “GAIN” is the core invented component, then coupled with Unsloth’s trainers/systems => AKA -> COLD FUSION.

The “GAIN” method (programming) automatically (and dynamically) changes training on a per sample basis in real time during training AS THE MODEL LEARNS.

The method improved metrics as well as overall model performance without overcooking or damaging the model.

This has also resulted, in the strongest and most stable model at both 4 bit and 8 bit and made 4 bit performance 99% of 8 bit performance too.

Note this model (Qwen3.8-27B-Cold-Fusion-GAIN-V1.1) is about a level 1 or 2 relative to Qwen3.6-27B-Fable-Fusion-711 at level 7-8.

https://huggingface.co/DavidAU/Qwen3.8-27B-Cold-Fusion-GAIN-V1.1-NM-DAU-NEO-MAX-MTP-GGUF

In the case of “Qwen3.8-27B-TURBO-Fable-Cold-Fusion-735-882-Heretic-Uncensored” it contains BOTH “Qwen3.6-27B-Fable-Fusion-711-Uncensored-Heretic” (DARK ROAST VERSION) and “Qwen3.8-27B-Cold-Fusion-GAIN-V1.1” as part of it’s critical/core “DNA”.

The final model was then HERETIC’ED (de-censored again) and fine tuned after this step.

COLAB:

A Colab between myself (multiple fine tunes, including multi-stage), Nightmedia (merge/benching), TeichAI (Polaris Dataset), armand0e (Light fable 5 traces), trohrbaugh (heretic’ing the model - STAGE1), and nbeerbower (various models/tunes using in part of the construction)

It also contains light “Fable” traces/training (armand0e), light Claude Opus (reasoning/thinking), F451 (inhouse dataset) , some GPT5 (Polaris, non reasoning) and several additional inhouse datasets specifically for machine learning / “heretic” repairs.

Here are links to fellow COLAB’ers:

This model is one of ELEVEN (all over 717 arc-c, with every model exceeding the core benches of Qwen 3.8 27B) Qwen 3.8 27B models designed by our team. Details of the builds and benches are here:

https://huggingface.co/DavidAU/Qwen3.8-27B-TURBO-Fable-Cold-Fusion-735-882-Heretic-Uncensored-NM-DAU

The strict goals of this model creation were: - Increase the general model intelligence and problem solving abilities. - DO NOT modify/damage or change the core model outside this goal. - ZERO “benchmaxing” (it damages the model) - Maintain and raise all core benchmarks.

CORE MISSION::

Improve instruction following and problem solving. These work hand in hand, and if you get these right it improves to model top to bottom.

It took a lot of tests on Qwen 3.5 9Bs to get the methods right. It boosted the 9Bs to new levels, and then the method was used on Qwen 3.5 27B and Qwen 3.6 27B which boosted it PAST the Qwen 3.8’s 27B benchmarks.

Here is one of the Qwen3.5 9B models (part of the test/control group) that EXCEEDS all 7 Qwen3.5 9B AND Qwen3.5 27B model benches - it scores over 640 on ARC-C on BOTH 4 bit and 8 bit:

https://huggingface.co/DavidAU/Qwen3.5-9B-The-Defiant-Fable-Uncensored-Heretic-NEO-IMATRIX-MAX-MTP-GGUF

It is not as strong as “Qwen3.8-27B-TURBO-Fable-Cold-Fusion-735-882-Heretic-Uncensored” but it is one of the strongest 9B models.

The methods can be used on other models too (coming soon).

TESTING:

Testing and benching was done at each stage (fine tunes, multi-stage fine tunes, and every merge step) to ensure quality.

You can also see benchmarks below too for this model, Qwen 3.5 27B, Qwen 3.6 27B and Qwen 35B-A3B.

HOWEVER, the final testing was HUMAN testing. A trust, but verify approach.

Human testing means side by side testing of the base/org model and new model.

Features: - Improved instruction following. - Overall increase in general intelligence and problem solving. - Better thinking/reasoning. - Even lower/lowest quants are exceptional. - Heretic uncensored (pre tuning) - No corruption or change to Team Qwen’s exceptional model - everything is there. - Vision

IMPORTANT - Notes and Usage Help:

This model, like regular Qwen 3.8 27b, supports THREE modes of reasoning : xhigh (default), medium and low [see info in Qwen 3.8 section below].

Reduction in thinking tokens/reasoning block size extends across all three modes of operation.

Likewise detail levels extend to all three modes too, even with reduced thinking/reasoning block the OUTPUT detail will remain high.

To REDUCE thinking block[s] further, increase the level/detail of your instructions/prompts - it only takes a little bit more here so the model has to guess / reason a little bit less.

Also, generally within the same chat additional reasoning blocks will also be reduced from typical Qwen levels many times hitting ¹⁄₅ the size or lower. Multi-turn chat - example: prompt, reasoning and 1st output - in the refinement stage(s) will see very strong reduction in thinking tokens/blocks.

Also note that the modification of “reasoning” is a major change to the model please carefully test it for your use case(s).

TOOL CALLING:

Min quant of q4km suggested, q5ks/5km better -> recommend Q6 [MAX or “low” (may work better for some apps)].

Temp: .6 / .7 ; Rep pen 1 (off).

Below q4km, tool calling may have issues. This is a general Qwen suggestion for tool calling specifically.

Also, overly agressive “caching” may further impair function(s).

GENERAL MODEL USAGE vs Qwen 3.8 27B “untuned”:

The tuning in this version of Qwen 3.8 27B reduced thinking/reasoning block size, in a lot of cases this has inverted the reasoning/thinking block size with the output size.

In other words, instead a lot of detail in the thinking/reasoning block (which may or may not show up in the output) has been transfered to the output in some cases.

Also, “untuned” Qwen 3.8 27B does a lot of look, look and look again (10k-40k+ in thinking/reasoning tokens alone) before you leap (gen output) whereas “TURBO” will leap almost immediately.

If you need higher quality reasoning and/or output here is how to get the model spend more time before it “leaps” (gen’s output):

REG PROMPT:

Generate an SVG of a pelican riding a bicycle.

EXPANDED PROMPT:

Generate an SVG of a pelican riding a bicycle, but carefully check the positioning and all elements.

The expanded prompt will tell the model to spend more time thinking/reasoning and in more detail before outputting the result and it is specific to the use case, rather than a generic “double check your work”.

Modification of REASONING:

If you AI app does not support a “switch” you can manually modify the JINJA template.

The default setting is “xhigh” ; to change to medium or low use:

{%- set reasoning_effort = 'medium' %}

OR

{%- set reasoning_effort = 'low' %}

Place this at the VERY TOP of the jinja template.

In LMStudio you can access this in DEV mode, and switch off the “advanced updates” option.

Other AI apps may vary.

You can also make your own quants from source here:

https://huggingface.co/DavidAU/Qwen3.8-27B-TURBO-Fable-Cold-Fusion-735-882-Heretic-Uncensored-NM-DAU

Just modify the “chat-template.jinja” (in NOTEPAD or similar) AND the token-config.. json file too (or delete the “chat template” from this file).

ADVANCED:

Qwen 3.8 uses System prompt injection control by the Jinja template to control reasoning levels.

If you set it at “medium” this turns off injection [ie: no system prompt is injected]

You can then set a “reasoning” system prompt yourself.

The other option:

Modify the jinja itself and the system prompt(s) to better tune reasoning to your use cases.

This is the section:

{%- if enable_thinking is undefined or enable_thinking is true %}
    {%- set resolved_reasoning_effort = reasoning_effort|default('xhigh') %}
    {%- if resolved_reasoning_effort not in ('xhigh', 'medium', 'low') %}
        {{- raise_exception('Unexpected reasoning effort ' ~ reasoning_effort ~ '. Supported types are xhigh (default), medium, and low.') }}
    {%- endif %}
    {%- if resolved_reasoning_effort == 'xhigh' %}
        {%- set reasoning_instructions = 'Reasoning effort is set to xhigh. Please think carefully through the task, validate key assumptions, consider plausible alternatives, and prioritize correctness, consistency, and clarity in the final answer.' %}
    {%- elif resolved_reasoning_effort == 'low' %}
        {%- set reasoning_instructions = 'Reasoning effort is set to low. Keep your thinking brief and focused, moving directly to the conclusion without unnecessary elaboration.' %}
    {%- endif %}
{%- endif %}

Regular and MTP GGUFS:

All quants (regular and MTP) are NEO IMATRIX, which improve accuracy of the quants by an additional 2-4% over normal GGUFs as well as long context performance.

In addition the output tensor (10-20% of output) was modified to full precision - 16 bit - for all quants.

“MTP” GGUFS (multi-token prediction): - “MTP” GGUFS will have “MTP” in the name as a suffix. - I have also set the MTP tensors to Q8_0 precision for all quants. - To get better performance keep temp 1 or less (higher temps degrade MTP performance). - Likewise with rep pen ; keep at 1 (off). If you raise it performance will suffer. - If you see “token acceptance” rates BELOW 50% (predict 2 tokens) switch to normal quants.

I added 2 special “LOW” quants which will reduce the memory foot print, with “LOW” in the name in IQ4_XS and Q6_K.

SPEED: - On Q4_K_S (4bit) quant, regular GGUFs are about 75 t/s, whereas MTP GGUFs (acceptance at 60%, 2 tokens) can exceed 90 T/S. (5090, Windows 11, testing in LMStudio) - Speeds will vary depending on GPU(s), AI app, O/S (Linux/Mac will generally be faster) and hardware. - “MTP” quants speeds will vary ; for creative/complex and/or temps over 1 use regular GGUFs for better performance.

I suggest you download at least one of each - regular and MTP gguf(s) - and test them for your use case(s).

If you get “token acceptance” (predict 2 tokens) with MTP quant(s) BELOW 50% (this means regular quants will run faster), then regular GGUF(s) will actually perform better - ie faster.

MTP quant(s) can in some cases run faster as the token window fills up and/or in multi turn chats.

Note there is NO other diffence between the quants type besides speed: both will do the same job.

Model: - 256k context - Gguf quants run in all standard AI apps. - Vision is activated, but you need to download separate “mmproj” file (ONE) to use it. VISION: - Vision (images) tested. - You need an “mmproj” (just one) of these downloaded too, and placed in the same folder as the GGUF for images. Qwen Model Settings (suggested):

Thinking mode for general tasks: temperature=1.0, top_p=0.95, top_k=20, min_p=0.0, presence_penalty=0.0, repetition_penalty=1.0
Thinking mode for precise coding tasks (e.g. WebDev): temperature=0.6, top_p=0.95, top_k=20, min_p=0.0, presence_penalty=0.0, repetition_penalty=1.0
Instruct (or non-thinking) mode: temperature=0.7, top_p=0.80, top_k=20, min_p=0.0, presence_penalty=1.5, repetition_penalty=1.0
Context window min from 8k to 16k.

DE-CENSORING STATS

Special thanks to: “trohrbaugh” (trohrbaugh/Qwen3.8-27B-heretic-ara) for Heretic’ing the model (stage 1).

This is a decensored version of Qwen/Qwen3.8-27B, made using

Heretic v1.2.0+custom with the Arbitrary-Rank Ablation (ARA) method

Performance

STAGE 1:

Metric	This model	Original model (Qwen/Qwen3.8-27B)
KL divergence	0.0535	0 (by definition)
Refusals	0/100	⁹⁹⁄₁₀₀

STAGE 2, at the end of STAGE 1 tuning/merges/adjustments (in lab):

Metric	This model	Original model (Stage 1 of the build)
KL divergence	0.0025	0 (by definition)
Refusals	¹¹⁄₁₀₀	⁸⁶⁄₁₀₀

NOTE:

LOWER “KLD” is better, and Stage 2 was balanced based on ultra low KLD first (performance, quality) matched with low refusal rate second.

BENCHMARKS by Nightmedia

Graphic below too, for all models listed below in order.

          arc/c arc/e boolq hswag obkqa piqa  wino

Qwen3.8-27B-TURBO-Fable-Cold-Fusion-735-882-Heretic-Uncensored
mxfp8     0.735,0.882,0.917,0.832,0.530,0.837,0.785
mxfp4     0.719,0.887,0.916,0.821,0.524,0.831,0.786

[QWENS] [base, non heretic, untuned]

Qwen3.8-27B: 
mxfp8     0.591,0.782,0.896,0.746,0.448,0.801,0.711
mxfp4     0.581,0.771,0.889,0.738,0.442,0.798,0.713

Qwen3.6-27B: 
mxfp8     0.647,0.803,0.910,0.773,0.450,0.806,0.742

Qwen3.6-35B-A3B-Instruct 
mxfp8     0.581,0.757,0.892,0.751,0.428,0.803,0.688

Qwen3.5-27B: 
mxfp8     0.557,0.711,0.868,0.533,0.452,0.706,0.695

NOTES: - Models are tested in “Instruct” mode because this generally works better with the testing harness. - Testing via “thinking” mode also shows the metrics (and changes) but not the true extent. - In actual fact when the model IS in thinking mode, it will exceed INSTRUCT benchmark scores in most cases. - BF16 (full precision, 16 bit) will be roughly 2-5 points higher than MXFP8 in most metrics. Some metrics may be slightly higher than this.

VISUAL:

-– Using an “uncensored” (refusals removed) model VS trained “uncensored” model

Usually when you a tell a model to generate horror, swear or x-rated content this is all you have to do to get said content type.

In the case of this model, it will not refuse your request, however it needs to be “pushed” a bit / directed a bit more in SOME CASES.

Although this model will generated x-rated content too, likewise you need to tell it to use “slang” (and include the terms you want) to get it generate the content correctly as the “expected” content level too.

Without these added directive(s), the content can be “bland” by comparison to an “uncensored model” or model trained on uncensored content.

Roughly, the model tries to generate the content but the “default” setting(s) are so “tame” it needs a push to generate at expected graphic, cursing or explicit levels.

Even with minimal direction (ie, use these words to swear: x,y,z), this will be enough to push the model to generate the requested content in the ahh… expected format.

Settings: CHAT / ROLEPLAY and/or SMOOTHER operation of this model:

In “KoboldCpp” or “oobabooga/text-generation-webui” or “Silly Tavern” ;

Set the “Smoothing_factor” to 1.5: in KoboldCpp -> Settings->Samplers->Advanced-> “Smooth_F”; in text-generation-webui -> parameters -> lower right.; In Silly Tavern this is called: “Smoothing”

NOTE: For “text-generation-webui”

-> if using GGUFs you need to use “llama_HF” (which involves downloading some config files from the SOURCE version of this model)

Source versions (and config files) of my models are here:

https://huggingface.co/collections/DavidAU/d-au-source-files-for-gguf-exl2-awq-gptq-hqq-etc-etc-66b55cb8ba25f914cbf210be

OTHER OPTIONS:

Increase rep pen to 1.1 to 1.15 (you don’t need to do this if you use “smoothing_factor”)
If the interface/program you are using to run AI MODELS supports “Quadratic Sampling” (“smoothing”) just make the adjustment as noted.

Highest Quality Settings / Optimal Operation Guide / Parameters and Samplers

This a “Class 1” model:

For all settings used for this model (including specifics for its “class”), including example generation(s) and for advanced settings guide (which many times addresses any model issue(s)), including methods to improve model performance for all use case(s) as well as chat, roleplay and other use case(s) please see:

[ https://huggingface.co/DavidAU/Maximizing-Model-Performance-All-Quants-Types-And-Full-Precision-by-Samplers_Parameters ]

You can see all parameters used for generation, in addition to advanced parameters and samplers to get the most out of this model here:

[ https://huggingface.co/DavidAU/Maximizing-Model-Performance-All-Quants-Types-And-Full-Precision-by-Samplers_Parameters ]

Qwen3.8-27B

[!Note] This repository contains model weights and configuration files for the post-trained model in the Hugging Face Transformers format.

These artifacts are compatible with Hugging Face Transformers, vLLM, SGLang, TokenSpeed, etc.

[!Tip] For users seeking managed, scalable inference without infrastructure maintenance, the official Qwen API service is provided by Qwen Cloud. In particular, Qwen3.8-27B will be available as a hosted version with more production features, e.g., 1M context length by default, official built-in tools. For more information, please refer to the Qwen3.8-27B Overview. The service is coming soon. Stay tuned for updates.

Following the widespread community adoption of the Qwen3.5 and Qwen3.6 series, we are pleased to introduce Qwen3.8, the most capable generation in the Qwen open-model family to date.

Built on the architectural foundation of Qwen3.5, Qwen3.8 delivers substantial gains across coding, professional work, research, and long-horizon agentic tasks. Qwen3.8-27B brings these advances to a compact, deployment-friendly dense model: a native vision-language model that understands images and videos, with flexible thinking control, designed to carry complex, multi-step tasks through to completion with greater reliability.

Qwen3.8 Highlights

Qwen3.8-27B features the following enhancements: - Core Capabilities: Comprehensive improvements across coding, professional work, research, and long-horizon agentic tasks. - Agent Execution: Stronger autonomous planning and better handling of environment feedback, leading to more reliable end-to-end task completion. - Downstream Compatibility: Broader support for popular harnesses and development tools, making it easier to integrate into your existing stack. - Flexible Thinking Control: Thinking mode is on by default and can be disabled per request; reasoning depth can be tuned with reasoning_effort, and reasoning context from historical messages is retained via preserve_thinking. - Vision-Language Understanding: Native support for image and video understanding, from STEM diagrams and documents to hour-scale videos.

Model Overview

Type: Causal Language Model with Vision Encoder
Training Stage: Pre-training & Post-training
Language Model
- Number of Parameters: 27B
- Hidden Dimension: 5120
- Token Embedding: 248,320 (Padded)
- Number of Layers: 64
- Hidden Layout: 16 × (3 × (Gated DeltaNet → FFN) → 1 × (Gated Attention → FFN))
- Gated DeltaNet:
  - Number of Linear Attention Heads: 48 for V and 16 for QK
  - Head Dimension: 128
- Gated Attention:
  - Number of Attention Heads: 24 for Q and 4 for KV
  - Head Dimension: 256
  - Rotary Position Embedding Dimension: 64
- Feed Forward Network:
  - Intermediate Dimension: 17,408
- LM Output: 248,320 (Padded)
- MTP (Multi-Token Prediction): trained with multiple steps
Context Length: 262,144 natively and extensible up to 1,000,000 tokens.

Benchmark Results

Text Performance

.vl-table th{font-size:15px!important;line-height:1.2} .vl-table td:not(.benchmark-cell):not([colspan]){font-size:15px;line-height:1.2;vertical-align:middle} .vl-table .benchmark-cell{padding:12px 10px 12px 18px!important;vertical-align:middle} .vl-table .benchmark-capability{font-size:15px;font-weight:600;line-height:1.22;color:#171717} .vl-table .benchmark-name{margin-top:4px;font-size:11px;font-weight:400;line-height:1.2;color:#6B6B6B} .vl-table .metric-stack{display:flex;flex-direction:column;gap:7px;padding:3px 0} .vl-table .metric-label{font-size:10px;font-weight:400;line-height:1.1;color:#777} .vl-table .metric-value{margin-top:2px;font-size:15px;line-height:1.15;color:#171717} | Qwen3.8-27B| Qwen3.6-27B| Qwen3.7-Plus| Muse Glimmer-30B| Opus4.6 Max

Coding
Agentic terminal codingTerminal Bench 2.1 (Terminus) | 73.0 | 63.4 | 64.0 | 51.7 | 78.2
Agentic codingSWE-bench Pro | 61.7 | 53.5 | 57.6 | 51.2 | 53.4
Repo-level code generationNL2Repo-Bench | 42.3 | 36.2 | 41.1 | -- | 47.6
Agentic codingDeepSWE 1.1 | 42.2 | 13.3 | 14.2 | -- | --
Software engineeringQwenSWEBench | 79.0 | 49.3 | 59.2 | -- | 63.8
Agent
Long-horizon office workCoWorkBench | 70.7 | 61.0 | 65.1 | -- | 68.2
Professional job tasksJobBench | 33.4 | 21.8 | 27.6 | -- | --
Frontier agentic tasksAgents’ Last Exam | Pass@120.4 Score42.9 | Pass@110.6Score27.3 | Pass@113.2Score33.6 | -- | --
General
Instruction followingIFBench | 79.5 | 69.1 | 79.1 | 77.0 | 62.5
Scientific reasoningGPQA Diamond | 89.2 | 87.8 | 90.3 | 83.5 | 91.3
Multidisciplinary reasoningHLE | 30.8 | 24.0 | 34.7 | 22.0 | 40.0
Competitive codingLiveCodeBench v6 | 90.3 | 83.9 | 89.6 | -- | 88.8

SWE-bench Pro: Except for Opus4.6 Max, which uses the officially reported score, all models are evaluated with the Claude Code harness at temp=1.0, top_p=0.95, and a 256K context window. Problematic tasks were corrected, and all baseline models were re-evaluated on the refined benchmark.
NL2Repo-Bench: Evaluated with the Claude Code harness. To prevent reward hacking, we disable Bash commands that attempt to access the specific repository, such as pip download, pip install, and git clone.
DeepSWE 1.1: Evaluated with the Claude Code harness at temp=1.0, top_p=0.95, and a 256K context window.
QwenSWEBench: In-house coding benchmark for evaluating models’ software engineering capabilities. Evaluated with the Claude Code harness. Reporting avg@3 with an 8-hour timeout, max_tokens=32,768, temperature=1.0, and a 256K context window.
CoWorkBench: In-house cowork benchmark for evaluating long-horizon tasks across computer science, finance, law, medical, and other productivity domains.
HLE: Judged by GPT-4o.
The best result in each row is shown in bold.
Empty cells (–) indicate that results are not yet available or not applicable.

VL Performance

Agentic Multimodal Intelligence
Computer useOSWorld-Verified| 84.3| 63.9| 73.3| 65.9| 72.7
Browser useWebArena-Verified| 64.8| 48.8| 55.3| --| --
Mobile useAndroidWorld| 81.9| 70.3| 81.0| --| 62.0
Application recreationRecreationBench| 47.1| 29.8| 30.2| --| --
Multimodal tool useClawEval-MM| Pass@357.4 Average56.9| Pass@342.6Average50.4| Pass@357.4 Average60.1| --| Pass@352.5Average54.7
Multimodal software engineeringSWE-MM| 38.6| 25.7| 30.0| --| 27.1
Visual web developmentVision2Web| 62.9| 45.0| 42.1| --| --
General Multimodal Intelligence
Visual math problem solvingMathVision| Without CI90.0With CI94.6| Without CI85.1| Without CI90.3| --| Without CI65.5
General visual reasoningBabyVision| Without CI65.7 With CI85.6| Without CI28.9| Without CI64.7With CI70.4| --| Without CI12.6
Scientific chart analysisCharXiv (RQ)| Without CI83.7With CI90.2| Without CI78.4| Without CI85.8 With CI85.9| 78.8| Without CI66.0
Document intelligenceOmniDocBench 1.5| 91.1| 89.4| 91.4| 75.8| 86.6
Real-world perceptionRealWorldQA| 85.9| 84.1| 86.9| --| 73.9
Embodied intelligenceERQA| 65.5| 62.5| 69.8| --| 40.8

MathVision, BabyVision, and CharXiv (RQ): Where both settings are available, cells report “Without CI” and “With CI” separately; otherwise, only the available setting is shown. A small number of incorrect ground-truth annotations in MathVision and CharXiv (RQ) were corrected following manual verification, and all reported scores on those benchmarks were computed using the corrected annotations.
MathVision: Qwen3.8-27B is evaluated using the fixed prompt: “Please reason step by step, and put your final answer within \boxed{}.” For the remaining models, we report the higher score from two prompt variants—one with and one without the \boxed{} formatting requirement.
WebArena-Verified: Scores are computed with the official WebArena-Verified grader under the OSWorld scaffold.
RecreationBench: An in-house, long-horizon application-recreation benchmark designed to evaluate hybrid-agent capabilities across five platforms: desktop (Ubuntu, macOS, and Windows), mobile (Android), and the web.
ClawEval-MM: Scores are reported as “Pass@3 / average score.” Pass@3 is the percentage of tasks passed in at least one of three trials; the average score is the mean benchmark score across the three trials.
Vision2Web: Scores are averaged across the frontend, webpage, and website categories. Evaluations use the Claude Code harness and are judged by gpt-5.4-2026-03-05.
SWE-MM: Scores are evaluated on the Claude Code harness using the public dev split of SWE-bench Multimodal, with the modifications described in Appendix 8.3 of the Claude Opus 4.7 system card.
Empty cells (–) indicate that results are not yet available or not applicable.