Qwen3.8 27B Cold Fusion GAIN V1.1 NM DAU NEO MAX MTP GGUF

IMPORTANT: The COLD FUSION (GAIN+Unsloth) method of training maintains 99% of performance of BF16, at both 8 bit and 4 bit levels. This version also reduces thinking tokens by 1/2 to as much as 1/10 the amount, while maintaining core details AND reasoning power. Model exceeds all Qwen 3.8, 3.6 and 3.5 27B critical core benchmarks. A model that gets down to business faster, with less "talking" and is smarter too.

Cold Fusion has 1/5 (as low as 1/10 in some cases) to 1/2 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 method of training.

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

EXAMPLE generations at the bottom of the page.

A Colab between myself (tuning, COLD Fusion), Nightmedia (benching), and TeichAI (Datasets).

The strict goals of this model creation were:

• Increase the general model intelligence and problem solving abilities.
• Reduce thinking block size from 1/2 to as low as 1/10 the size [median reduction: 2/3 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:

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" (2100+ 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.

A stronger, more in depth tune of Qwen3.8-27B (including ablit/uncensored) using both COLD Fusion method and the "Fable-Fusion-711" pipeline is planned. This is also a heavier undertaking which takes 7-10 days (min) to complete as it includes 6 stages plus multiple sub-stages.

TESTING:

Testing and benching was done at each stage to ensure quality.

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

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 with far smaller thinking/reasoning blocks, output generation will also be compressed by default in many cases.
• Even lower/lowest quants are exceptional.
• No corruption or change to Team Qwen's exceptional model - everything is there.
• Vision

IMPORTANT:

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 1/5 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).

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:

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-Cold-Fusion-GAIN-V1.1

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:

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 have also added two "LOW" quants, with "LOW" in the name:

• IQ4_XS and Q6_K
• These are for max speed / reduced VRAM and without MTP/OT mods.
• Performance may be slightly lower than the reg "MAX" quants.

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) 3.8 and 3.5/3.6:

Qwen 3.8 uses the same framework (tensors, layers, repeating 4 layers, etc) as Qwen 3.5 and 3.6 ; however with new reasoning options the best settings for your uses cases may vary IE you might find Qwen 3.5/.6 settings better and/or Qwen 3.8 settings.

NOTES - GENERAL:

• Due to Qwen 3.8's new reasoning options you may need to adjust parameters - especially temp - slightly.
• Also, lower quants (Q4ks and lower) may benefit from slightly higher temps for some use cases.

NOTE presence_penalty:

• If this is set, it can have major impact (neg) on coding, math and/or other specific use cases with high "repeats" in the thinking and/or output.
• If you use it, start LOW IE 0.25 and increase only as you need to.
• My view: ONLY set this if you need it ; it prevents loops / other issues in some use case(s).

QWEN 3.8 SETTINGS, including this model (from Qwen):

• Thinking Mode: temperature=1.0, 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 ; suggest 24k to 32k even with reduced reasoning blocks.

QWEN 3.5/3.6 SETTINGS (from Qwen):

• 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 ; suggest 24k to 32k even with reduced reasoning blocks.

Important note on Qwen 27B 3.8 bench VS Qwen 3.6/3.5 27B versions:

Based on my testing / Qwen's own statements, community statements (ie localllama) and extended benchs for 3.8-27B version (team Qwen) this model is more focused on deeper thinking, coding and agentic functions than previous Qwen versions.

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.

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 ]

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 Performance

Quickstart

For streamlined integration, we recommend using Qwen3.8 via APIs.

Serving Qwen3.8

Qwen3.8 can be deployed with popular inference frameworks, e.g.:

• SGLang: Qwen3.8 Cookbook
• vLLM: Qwen3.8 Recipe
• TokenSpeed: Qwen3.8 Recipe

API Usage

Qwen3.8 comes with official support for reasoning_effort, which can be used to adjust reasoning depth and control cost:

• xhigh (default): for complex tasks demanding thorough analysis
• medium: balancing accuracy and speed
• low: efficient reasoning optimizing for speed and cost

In addition, preserve_thinking is enabled by default for all workloads for the best out-of-the-box experience. To disable preserved thinking, refer to the examples here.

Chat Completions API

The Chat Completions API can be used with most inference frameworks, as well as Qwen Cloud. Before starting, make sure the OpenAI Python SDK is installed and the API key and the API base URL are configured, e.g.:

pip install -U openai


export OPENAI_BASE_URL='your-base-url'
export OPENAI_API_KEY='your-api-key'

Text-Only Input

from openai import OpenAI

client = OpenAI()

messages = [{"role": "user", "content": "Write a Python function to merge two sorted linked lists."}]

completion = client.chat.completions.create(
    model="Qwen/Qwen3.8-27B",
    messages=messages,
    extra_body={
        "chat_template_kwargs": {
            "enable_thinking": True,  # on by default
            "preserve_thinking": True, # on by default
        },
    },
    reasoning_effort="xhigh",  # xhigh by default; supported levels are xhigh, medium, and low
    stream=True,
    stream_options={"include_usage": True},
)

reasoning_content = ""
answer_content = ""
is_answering = False
print("\n" + "=" * 20 + "Reasoning" + "=" * 20 + "\n")

for chunk in completion:
    if not chunk.choices:
        print("\nUsage:")
        print(chunk.usage)
        continue

    delta = chunk.choices[0].delta

    if hasattr(delta, "reasoning_content") and delta.reasoning_content is not None:
        if not is_answering:
            print(delta.reasoning_content, end="", flush=True)
        reasoning_content += delta.reasoning_content
    elif hasattr(delta, "reasoning") and delta.reasoning is not None:
        if not is_answering:
            print(delta.reasoning, end="", flush=True)
        reasoning_content += delta.reasoning

    if hasattr(delta, "content") and delta.content:
        if not is_answering:
            print("\n" + "=" * 20 + "Answer" + "=" * 20 + "\n")
            is_answering = True
        print(delta.content, end="", flush=True)
        answer_content += delta.content

messages.append({
    "role": "assistant",
    "content": answer_content,
    "reasoning_content": reasoning_content,
    "reasoning": reasoning_content,
})

Image Input

from openai import OpenAI

client = OpenAI()

messages = [
    {
        "role": "user",
        "content": [
            {
                "type": "image_url",
                "image_url": {
                    "url": "https://qianwen-res.oss-accelerate.aliyuncs.com/Qwen3.5/demo/CI_Demo/mathv-1327.jpg"
                }
            },
            {
                "type": "text",
                "text": "The centres of the four illustrated circles are in the corners of the square. The two big circles touch each other and also the two little circles. With which factor do you have to multiply the radii of the little circles to obtain the radius of the big circles?\nChoices:\n(A) $\\frac{2}{9}$\n(B) $\\sqrt{5}$\n(C) $0.8 \\cdot \\pi$\n(D) 2.5\n(E) $1+\\sqrt{2}$"
            }
        ]
    }
]

chat_response = client.chat.completions.create(
    model="Qwen/Qwen3.8-27B",
    messages=messages,
)
print("Chat response:", chat_response)

Video Input

from openai import OpenAI

client = OpenAI()

messages = [
    {
        "role": "user",
        "content": [
            {
                "type": "video_url",
                "video_url": {
                    "url": "https://qianwen-res.oss-accelerate.aliyuncs.com/Qwen3.5/demo/video/N1cdUjctpG8.mp4"
                }
            },
            {
                "type": "text",
                "text": "How many porcelain jars were discovered in the niches located in the primary chamber of the tomb?"
            }
        ]
    }
]

chat_response = client.chat.completions.create(
    model="Qwen/Qwen3.8-27B",
    messages=messages,
)














print("Chat response:", chat_response)

Instruct (or Non-Thinking) Mode

Qwen3.8-27B will think by default before responding. You can obtain a direct response from the model without thinking by configuring the API parameters. For example,

from openai import OpenAI

client = OpenAI()

messages = [
    {
        "role": "user",
        "content": [
            {
                "type": "image_url",
                "image_url": {
                    "url": "https://qianwen-res.oss-accelerate.aliyuncs.com/Qwen3.5/demo/RealWorld/RealWorld-04.png"
                }
            },
            {
                "type": "text",
                "text": "Where is this?"
            }
        ]
    }
]

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},
    }, 
)
print("Chat response:", chat_response)

Disable Preserved Thinking

By default, Qwen3.8 retains thinking blocks from all historical messages, maintaining a complete reasoning trace across the conversation. This behavior, known as preserved thinking, ensures full context continuity and is especially beneficial for agent scenarios where decision consistency and reduced redundant reasoning are critical. It also improves KV cache utilization, optimizing inference efficiency in both thinking and non-thinking modes.

If you prefer to retain only the thinking blocks from the latest user message, you can disable this behavior by setting preserve_thinking to False:

from openai import OpenAI


client = OpenAI()
messages = [...]
chat_response = client.chat.completions.create(
    model="Qwen/Qwen3.8-27B",
    messages=messages,
    extra_body={
        "chat_template_kwargs": {"preserve_thinking": False},
    },
)
print("Chat response:", chat_response)

Best Practices

To achieve optimal performance, we recommend the following settings:

1. Sampling Parameters: We suggest using the following sets of sampling parameters:

   • Thinking Mode: temperature=1.0, 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

   For supported frameworks, you can adjust the presence_penalty parameter between 0 and 2 to reduce endless repetition. However, using a higher value may occasionally result in language mixing and a slight decrease in model performance.

2. Adequate Output Length: To optimize performance on agentic tasks, we recommend allocating sufficient output length to allow the model to generate detailed and comprehensive responses. For frameworks that support separate token limits for internal reasoning and final outputs, we suggest the following configuration within the 1M context length:

   • Reasoning Content: Set the maximum output length to 262,144 tokens.
   • Final Response: Set the maximum output length to 131,072 tokens.

   These settings provide the necessary capacity for complex reasoning while ensuring ample space for high-quality final deliverables.

3. Processing Ultra-Long Texts: Qwen3.8-27B natively supports context lengths of up to 262,144 tokens. For long-horizon tasks where the total length (including both input and output) exceeds this limit, we recommend using RoPE scaling techniques to handle long texts effectively, e.g., YaRN.

   YaRN is currently supported by several inference frameworks, e.g., vLLM, SGLang, and TokenSpeed. In general, there are two approaches to enabling YaRN for supported frameworks:

   • Modifying the model configuration file:

     In the config.json file, change the rope_parameters fields in text_config to:

     {
         "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,
     }

   • Passing command line arguments:

     For vLLM, you can use

     VLLM_ALLOW_LONG_MAX_MODEL_LEN=1 vllm serve ... --hf-overrides '{"text_config": {"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}}}' --max-model-len 1000000

     For SGLang, you can use

     SGLANG_ALLOW_OVERWRITE_LONGER_CONTEXT_LEN=1 python -m sglang.launch_server ... --json-model-override-args '{"text_config": {"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}}}' --context-length 1000000

     For TokenSpeed, you can use

     TOKENSPEED_ALLOW_OVERWRITE_LONGER_CONTEXT_LEN=1 tokenspeed serve ... --hf-overrides '{"text_config": {"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}}}' --max-model-len 1000000

   [!NOTE] All the notable open-source frameworks implement static YaRN, which means the scaling factor remains constant regardless of input length, potentially impacting performance on shorter texts. We advise modifying the rope_parameters configuration only when processing long contexts is required. It is also recommended to modify the factor as needed. For example, if the typical context length for your application is 524,288 tokens, it would be better to set factor as 2.0.

4. Long Video Understanding: To optimize inference efficiency for plain text and images, the size parameter in the released video_preprocessor_config.json is conservatively configured. It is recommended to set the longest_edge parameter in the video_preprocessor_config file to 469,762,048 (corresponding to 224k video tokens) to enable higher frame-rate sampling for hour-scale videos and thereby achieve superior performance. For example,

   {"longest_edge": 469762048, "shortest_edge": 4096}

   Alternatively, override the default values via engine startup parameters. For implementation details, refer to: vLLM / SGLang.

Citation

If you find our work helpful, feel free to give us a cite.

@misc{qwen38,
    title = {{Qwen3.8-Max}: A New Bar for Coding and Cowork},
    url = {https://qwen.ai/blog?id=qwen3.8},
    author = {{Qwen Team}},
    month = {August},
    year = {2026}
}

Q4KS, non imatrix, standard Qwen settings, NO cache compression of any kind.

NOTE: Some formatting may be lost on copy/paste/export.