Qwen3.8-27B-FP8-dynamic API & Inference Endpoint

What was quantized

The language model is quantized; the vision tower is not. Within the language model, three groups are deliberately held at bf16.

Table with columns: Component, Precision
Component	Precision
MLP `gate_proj` / `up_proj` / `down_proj`	FP8 dynamic (W8A8)
Gated DeltaNet `in_proj_qkv` / `in_proj_z` / `out_proj`	FP8 dynamic (W8A8)
Attention `q_proj` / `k_proj` / `v_proj` / `o_proj`	FP8 dynamic (W8A8)
Gated DeltaNet `in_proj_a` / `in_proj_b`	bf16
`lm_head`	bf16
Vision tower (`model.visual.*`)	bf16
All normalization layers, `conv1d`, embeddings	bf16 (untouched)

93.28% of all nn.Linear weight is quantized; 6.72% is held at bf16.

Why those three stay in bf16:

lm_head is a 5120 x 248320 projection feeding the softmax directly — the most accuracy-sensitive layer in the model.
The vision tower is 456M of 26B parameters. Quantizing it saves almost nothing while every answer is conditioned on its output.
in_proj_a / in_proj_b emit the per-head decay and delta-rule beta that drive the Gated DeltaNet recurrence. Error there compounds along the whole sequence instead of staying local to one position, and at 0.09% of Linear weight they are the cheapest place to spend precision.

Quantization configuration

Table

Method	`llmcompressor` 0.13.0
Scheme	`FP8_DYNAMIC`
Weights	8-bit float (E4M3), per-channel scale
Activations	8-bit float (E4M3), per-token scale computed at runtime
SmoothQuant	enabled, alpha = 0.8
Calibration data	`abisee/cnn_dailymail` (512 samples @ 2048 tokens)
Modules held at bf16	207

Benchmark results

Performance

Thinking enabled at the model's default reasoning_effort, greedy decoding. This is how the model is meant to be run, so these are the only absolute scores quoted here.

Table with columns: Task, n, This model, bf16, Qwen card
Task	n	This model	bf16	Qwen card
MathVision (testmini)	304	82.89	86.18	90.0
ERQA	400	65.25	65.00	65.5

The bf16 column is our own measurement of the original weights under this harness, and it lands within half a point of Qwen's published ERQA figure — which is the evidence that the harness measures what their card measures. The remaining gaps are protocol: every run here is greedy, while Qwen sample at temperature 1.0 / top_p 0.95 / top_k 20.

How far this checkpoint drifts from bf16

Absolute scores are a poor instrument for this question. With thinking on, the same bf16 weights measured twice — changing only the batch size — move up to 2.30 points on their own, because greedy decoding is not reproducible on this architecture: vLLM's VLLM_BATCH_INVARIANT mode refuses to start (not supported for GDN_ATTN; 48 of the 64 layers are Gated DeltaNet), so GEMM reduction order still depends on how requests batch together, and one flipped token early in a long chain rewrites everything after it.

Short answers do not have that problem: there the pipeline reproduces itself to within 0.13 points. So the comparison below runs in that regime — chosen for measurement sensitivity, not because it reflects normal use. It reports drift only, never a score.

Table with columns: Task, n, Δ vs bf16, floor, verdict
Task	n	Δ vs bf16	floor	verdict
AI2D	3,088	-0.58	0.00	no measurable difference
ChartQA	2,500	-0.08	0.00	no measurable difference
ScienceQA-IMG	2,017	+0.00	0.05	no measurable difference

floor is how far the score moved between two runs of the unmodified bf16 weights. A Δ smaller than the floor beside it is a property of the inference pipeline, not of quantization. p-values are Holm-Bonferroni adjusted across all 30 task × checkpoint tests; without that correction roughly one would reach significance by chance.

10 tasks, 13,046 documents, deterministic scorers only. Tasks graded by an LLM judge (MathVista, MMMU, CharXiv, HallusionBench, MMBench) are excluded: a second model's variance has no place in a measurement about numerics.

Table

Quantized weights	28.3 GB
Hardware	1x NVIDIA H100 80GB HBM3
Runtime	vLLM 0.27.1
Harness	lmms-eval, greedy decoding

Usage

No quantization flag is required — vLLM reads the format from config.json.

bash
vllm serve vrfai/Qwen3.8-27B-FP8-dynamic --trust-remote-code

python
from vllm import LLM, SamplingParams

llm = LLM(
    model="vrfai/Qwen3.8-27B-FP8-dynamic",
    trust_remote_code=True,
    max_num_seqs=64,   # Gated DeltaNet holds one state block per decode
                       # sequence, so the default 1024 exceeds the pool
)
print(llm.generate(["The capital of France is"],
                   SamplingParams(temperature=0.0, max_tokens=64))[0].outputs[0].text)

Requires vLLM >= 0.27.1, the first release with Qwen3_5ForConditionalGeneration.

[!WARNING] Everything below this line is reproduced verbatim from the base model card, Qwen/Qwen3.8-27B. The benchmark tables it contains were measured by the Qwen team on the original bf16 weights. They were not measured on this quantized checkpoint. For numbers measured on these weights, see the Benchmark results section above.

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

Benchmark Results

Text Performance

VL Performance

Quickstart

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

Serving Qwen3.8

[!Important] Inference efficiency and throughput vary significantly across frameworks. We recommend using the latest framework versions to ensure optimal performance and compatibility. For production workloads or high-throughput scenarios, dedicated serving engines such as SGLang, vLLM, or TokenSpeed are recommended.

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

API Usage

[!Important] Qwen3.8 models operate in thinking mode by default, generating thinking content signified by <think>\n...</think>\n\n before producing the final response. To disable thinking content and obtain a direct response, refer to the examples here.

[!Tip] We recommend using the following sets of sampling parameters for generation:

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

Please note that the support for sampling parameters varies according to inference frameworks.

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.

[!Tip] In multi-turn agentic tasks, lower reasoning effort does not always reduce overall task completion time. Although it may produce faster per-turn responses, it can also lead to insufficient analysis, more failures, and repeated retries, which may increase total latency and token consumption.

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.:

shell
pip install -U openai

# Set the following accordingly
export OPENAI_BASE_URL='your-base-url'
export OPENAI_API_KEY='your-api-key'

Text-Only Input

python
from openai import OpenAI
# Configured by environment variables
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

python
from openai import OpenAI
# Configured by environment variables
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

python
from openai import OpenAI
# Configured by environment variables
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,
)

# When vLLM is launched with `--media-io-kwargs '{"video": {"num_frames": -1}}'`,
# video frame sampling can be configured via `extra_body` (e.g., by setting `fps`).
# This feature is currently supported only in vLLM.
#
# By default, `fps=2` and `do_sample_frames=True`.
# With `do_sample_frames=True`, you can customize the `fps` value to set your desired video sampling rate.
# chat_response = client.chat.completions.create(
#     model="Qwen/Qwen3.8-27B",
#     messages=messages,
#     extra_body={
#         "mm_processor_kwargs": {"fps": 2, "do_sample_frames": True},
#     }, 
# )

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,

python
from openai import OpenAI
# Configured by environment variables
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)

[!Note] If you are using APIs from Qwen Cloud, in addition to changing model, please use "enable_thinking": False instead of "chat_template_kwargs": {"enable_thinking": False}.

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:

python
from openai import OpenAI

# Configured by environment variables
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)

[!Note] If you are using APIs from Qwen Cloud, in addition to changing model, please use "preserve_thinking": False directly instead of wrapping it in chat_template_kwargs.

Best Practices

To achieve optimal performance, we recommend the following settings:

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 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.

Citation

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

bibtex
@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}
}

What was quantized

The language model is quantized; the vision tower is not. Within the language model, three groups are deliberately held at bf16.

Table with columns: Component, Precision
Component	Precision
MLP `gate_proj` / `up_proj` / `down_proj`	FP8 dynamic (W8A8)
Gated DeltaNet `in_proj_qkv` / `in_proj_z` / `out_proj`	FP8 dynamic (W8A8)
Attention `q_proj` / `k_proj` / `v_proj` / `o_proj`	FP8 dynamic (W8A8)
Gated DeltaNet `in_proj_a` / `in_proj_b`	bf16
`lm_head`	bf16
Vision tower (`model.visual.*`)	bf16
All normalization layers, `conv1d`, embeddings	bf16 (untouched)

93.28% of all nn.Linear weight is quantized; 6.72% is held at bf16.

Why those three stay in bf16:

lm_head is a 5120 x 248320 projection feeding the softmax directly — the most accuracy-sensitive layer in the model.
The vision tower is 456M of 26B parameters. Quantizing it saves almost nothing while every answer is conditioned on its output.
in_proj_a / in_proj_b emit the per-head decay and delta-rule beta that drive the Gated DeltaNet recurrence. Error there compounds along the whole sequence instead of staying local to one position, and at 0.09% of Linear weight they are the cheapest place to spend precision.

Quantization configuration

Table

Method	`llmcompressor` 0.13.0
Scheme	`FP8_DYNAMIC`
Weights	8-bit float (E4M3), per-channel scale
Activations	8-bit float (E4M3), per-token scale computed at runtime
SmoothQuant	enabled, alpha = 0.8
Calibration data	`abisee/cnn_dailymail` (512 samples @ 2048 tokens)
Modules held at bf16	207

Benchmark results

Performance

Thinking enabled at the model's default reasoning_effort, greedy decoding. This is how the model is meant to be run, so these are the only absolute scores quoted here.

Table with columns: Task, n, This model, bf16, Qwen card
Task	n	This model	bf16	Qwen card
MathVision (testmini)	304	82.89	86.18	90.0
ERQA	400	65.25	65.00	65.5

How far this checkpoint drifts from bf16

Table with columns: Task, n, Δ vs bf16, floor, verdict
Task	n	Δ vs bf16	floor	verdict
AI2D	3,088	-0.58	0.00	no measurable difference
ChartQA	2,500	-0.08	0.00	no measurable difference
ScienceQA-IMG	2,017	+0.00	0.05	no measurable difference

Table

Quantized weights	28.3 GB
Hardware	1x NVIDIA H100 80GB HBM3
Runtime	vLLM 0.27.1
Harness	lmms-eval, greedy decoding

Usage

No quantization flag is required — vLLM reads the format from config.json.

bash
vllm serve vrfai/Qwen3.8-27B-FP8-dynamic --trust-remote-code

python
from vllm import LLM, SamplingParams

llm = LLM(
    model="vrfai/Qwen3.8-27B-FP8-dynamic",
    trust_remote_code=True,
    max_num_seqs=64,   # Gated DeltaNet holds one state block per decode
                       # sequence, so the default 1024 exceeds the pool
)
print(llm.generate(["The capital of France is"],
                   SamplingParams(temperature=0.0, max_tokens=64))[0].outputs[0].text)

Requires vLLM >= 0.27.1, the first release with Qwen3_5ForConditionalGeneration.

[!WARNING] Everything below this line is reproduced verbatim from the base model card, Qwen/Qwen3.8-27B. The benchmark tables it contains were measured by the Qwen team on the original bf16 weights. They were not measured on this quantized checkpoint. For numbers measured on these weights, see the Benchmark results section above.

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.

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

Benchmark Results

Text Performance

VL Performance

Quickstart

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

Serving Qwen3.8

[!Important] Inference efficiency and throughput vary significantly across frameworks. We recommend using the latest framework versions to ensure optimal performance and compatibility. For production workloads or high-throughput scenarios, dedicated serving engines such as SGLang, vLLM, or TokenSpeed are recommended.

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

API Usage

[!Important] Qwen3.8 models operate in thinking mode by default, generating thinking content signified by <think>\n...</think>\n\n before producing the final response. To disable thinking content and obtain a direct response, refer to the examples here.

[!Tip] We recommend using the following sets of sampling parameters for generation:

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

Please note that the support for sampling parameters varies according to inference frameworks.

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.

[!Tip] In multi-turn agentic tasks, lower reasoning effort does not always reduce overall task completion time. Although it may produce faster per-turn responses, it can also lead to insufficient analysis, more failures, and repeated retries, which may increase total latency and token consumption.

Chat Completions API

shell
pip install -U openai

# Set the following accordingly
export OPENAI_BASE_URL='your-base-url'
export OPENAI_API_KEY='your-api-key'

Text-Only Input

python
from openai import OpenAI
# Configured by environment variables
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

python
from openai import OpenAI
# Configured by environment variables
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

python
from openai import OpenAI
# Configured by environment variables
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,
)

# When vLLM is launched with `--media-io-kwargs '{"video": {"num_frames": -1}}'`,
# video frame sampling can be configured via `extra_body` (e.g., by setting `fps`).
# This feature is currently supported only in vLLM.
#
# By default, `fps=2` and `do_sample_frames=True`.
# With `do_sample_frames=True`, you can customize the `fps` value to set your desired video sampling rate.
# chat_response = client.chat.completions.create(
#     model="Qwen/Qwen3.8-27B",
#     messages=messages,
#     extra_body={
#         "mm_processor_kwargs": {"fps": 2, "do_sample_frames": True},
#     }, 
# )

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,

python
from openai import OpenAI
# Configured by environment variables
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)

[!Note] If you are using APIs from Qwen Cloud, in addition to changing model, please use "enable_thinking": False instead of "chat_template_kwargs": {"enable_thinking": False}.

Disable Preserved Thinking

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:

python
from openai import OpenAI

# Configured by environment variables
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)

[!Note] If you are using APIs from Qwen Cloud, in addition to changing model, please use "preserve_thinking": False directly instead of wrapping it in chat_template_kwargs.

Best Practices

To achieve optimal performance, we recommend the following settings:

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 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.

Citation

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

bibtex
@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}
}

Qwen3.8-27B-FP8-dynamic

README

What was quantized

Quantization configuration

Benchmark results

Performance

How far this checkpoint drifts from bf16

Usage

Qwen3.8-27B

Qwen3.8 Highlights

Model Overview

Benchmark Results

Text Performance

VL Performance

Quickstart

Serving Qwen3.8

API Usage

Chat Completions API

Text-Only Input

Image Input

Video Input

Instruct (or Non-Thinking) Mode

Disable Preserved Thinking

Best Practices

Citation

Explore FriendliAI today

README

What was quantized

Quantization configuration

Benchmark results

Performance

How far this checkpoint drifts from bf16

Usage

Qwen3.8-27B

Qwen3.8 Highlights

Model Overview

Benchmark Results

Text Performance

VL Performance

Quickstart

Serving Qwen3.8

API Usage

Chat Completions API

Text-Only Input

Image Input

Video Input

Instruct (or Non-Thinking) Mode

Disable Preserved Thinking

Best Practices

Citation