GLM-5.3 is live. Run Z.ai's latest model on Friendli Model APIs. Try it today ➜
AMAImedia
Available on FriendliAI
Run this model inference on single tenant GPU with unmatched speed and reliability at scale.
Model Details
Model Provider
AMAImedia
Model Tree
nlpguy/Qwen3.8-27B-Kimiko-2
Input Modalities
Output Modalities
Supported Functionality
Released as part of the NOESIS Professional Multilingual Dubbing Automation Platform (framework: DHCF-FNO — Deterministic Hybrid Control Framework for Frozen Neural Operators).
This is a merge of pre-trained language models created using mergekit.
lm-evaluation-harness 0.4.12, chat template applied, max_gen_toks=4096, full datasets. Base measured under the identical harness.
| Qwen3.8-27B | Kiwen-27B | Kiwen1.1-27B | Kimiko-2-27B | |
|---|---|---|---|---|
| GSM8K strict | 67.4 | 72.78 | 96.4 | TBD |
| GSM8K flexible | 74.9 | 84.38 | 96.7 | TBD |
| IFEval prompt strict | 80.4 | 84.29 | 83.9 | TBD |
Kimiko-2-27B status: TBD. These values must be measured on the merged checkpoint using the same
lm-evaluation-harnessversion, chat template, prompts, generation limits, and dataset revisions as the comparison columns. They cannot be calculated reliably from the component-model scores.
GSM8K moves by 29 points. That is the headline number and it is real, on the full 1,319-item set. Base and fine-tune were run back to back in the same job so the two columns share their conditions. A second independent run of the fine-tune scored 96.2 / 96.4, which puts the run-to-run spread around 0.3.
VMLU moves much less: +1.3 over the base, against Kiwen-27B's +2.5. The gain is real but small. The training mix is weighted toward reasoning and tool use, not toward Vietnamese factual recall, so a model tuned directly for that recall stays ahead. Base VMLU breaks down as STEM 93.4, Social Science 82.4, Other 78.6, Humanity 74.7, and the humanities gap is where the headroom is.
Internal benchmark
On an internal 20-task suite the model won 5, lost 6 and tied 5, median delta 0.0. The wins are concentrated in classification and routing:
| Task | Delta |
|---|---|
| Translation | +22.9 |
| Intent classification | +20.9 |
| Intent routing | +20.7 |
| Multi-turn tool calling | +15.1 |
This model was merged using the Karcher Mean merge method.
The following models were included in the merge:
The following YAML configuration was used to produce this model:
yaml
chat_template: qwendtype: bfloat16merge_method: karchermodules:default:slices:- sources:- layer_range: [0, 0]model: nlpguy/Qwen3.8-27B-Fimi-4- layer_range: [0, 0]model: beyoru/Kiwen1.1-27B- layer_range: [0, 0]model: Qwen/Qwen3.8-27B- layer_range: [0, 0]model: TeichAI/Qwen3.8-27B-Fable-Distillmodel.language_model.layers:slices:- sources:- layer_range: [0, 64]model: nlpguy/Qwen3.8-27B-Fimi-4- layer_range: [0, 64]model: beyoru/Kiwen1.1-27B- layer_range: [0, 64]model: Qwen/Qwen3.8-27B- layer_range: [0, 64]model: TeichAI/Qwen3.8-27B-Fable-Distillmodel.visual.blocks:slices:- sources:- layer_range: [0, 27]model: nlpguy/Qwen3.8-27B-Fimi-4- layer_range: [0, 27]model: beyoru/Kiwen1.1-27B- layer_range: [0, 27]model: Qwen/Qwen3.8-27B- layer_range: [0, 27]model: TeichAI/Qwen3.8-27B-Fable-Distillout_dtype: bfloat16
The following YAML configuration was used to produce this model:
yaml
base_model: Qwen/Qwen3.5-27Bchat_template: qwendtype: bfloat16merge_method: ramplus_tlmodules:default:slices:- sources:- layer_range: [0, 0]model: Danielbrdz/Barcenas-Qwen3.8-27B-Fable- layer_range: [0, 0]model: allenai/tmax-27b- layer_range: [0, 0]model: migtissera/Tess-4-27B- layer_range: [0, 0]model: beyoru/Kiwen1.1-27B- layer_range: [0, 0]model: empero-ai/Qwythos-27B-v1- layer_range: [0, 0]model: bottlecapai/ThinkingCap-Qwen3.6-27B- layer_range: [0, 0]model: TeichAI/Qwen3.8-27B-Fable-Distill- layer_range: [0, 0]model: Qwen/Qwen3.5-27Bmodel.language_model.layers:slices:- sources:- layer_range: [0, 64]model: Danielbrdz/Barcenas-Qwen3.8-27B-Fable- layer_range: [0, 64]model: allenai/tmax-27b- layer_range: [0, 64]model: migtissera/Tess-4-27B- layer_range: [0, 64]model: beyoru/Kiwen1.1-27B- layer_range: [0, 64]model: empero-ai/Qwythos-27B-v1- layer_range: [0, 64]model: bottlecapai/ThinkingCap-Qwen3.6-27B- layer_range: [0, 64]model: TeichAI/Qwen3.8-27B-Fable-Distill- layer_range: [0, 64]model: Qwen/Qwen3.5-27Bmodel.visual.blocks:slices:- sources:- layer_range: [0, 27]model: Danielbrdz/Barcenas-Qwen3.8-27B-Fable- layer_range: [0, 27]model: allenai/tmax-27b- layer_range: [0, 27]model: migtissera/Tess-4-27B- layer_range: [0, 27]model: beyoru/Kiwen1.1-27B- layer_range: [0, 27]model: empero-ai/Qwythos-27B-v1- layer_range: [0, 27]model: bottlecapai/ThinkingCap-Qwen3.6-27B- layer_range: [0, 27]model: TeichAI/Qwen3.8-27B-Fable-Distill- layer_range: [0, 27]model: Qwen/Qwen3.5-27Bout_dtype: bfloat16parameters:r: 0.25
[!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-27B features the following enhancements:
reasoning_effort, and reasoning context from historical messages is retained via preserve_thinking.For streamlined integration, we recommend using Qwen3.8 via APIs.
[!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.:
Install the latest vLLM release and start an OpenAI-compatible server. Use a recent vLLM version with Qwen3.8 support.
bash
pip install -U vllmvllm serve AMAImedia/Qwen3.8-27B-Kimiko-2-BF16 \--trust-remote-code \--max-model-len 32768 \--gpu-memory-utilization 0.90
For multiple GPUs, add --tensor-parallel-size N, where N is the number of GPUs. Start with --max-model-len 32768 and increase it only after confirming available memory. The server exposes an OpenAI-compatible endpoint at http://localhost:8000/v1.
bash
curl http://localhost:8000/v1/chat/completions \-H "Content-Type: application/json" \-d '{"model": "AMAImedia/Qwen3.8-27B-Kimiko-2-BF16","messages": [{"role": "user", "content": "Explain what this model is."}],"temperature": 0.7,"max_tokens": 512}'
Ollama normally requires an Ollama-compatible model file, most commonly GGUF. This repository contains BF16 safetensors, so it may not be directly loadable by Ollama. Convert the model to a compatible GGUF build first, then create an Ollama model from that file.
Create a file named Modelfile next to the converted GGUF file:
text
FROM ./Qwen3.8-27B-Kimiko-2-Q4_K_M.ggufPARAMETER num_ctx 32768PARAMETER temperature 0.7PARAMETER top_p 0.8
Build and run it:
bash
ollama create qwen3.8-kimiko-2 -f Modelfileollama run qwen3.8-kimiko-2
For the local Ollama API:
bash
curl http://localhost:11434/api/chat \-H "Content-Type: application/json" \-d '{"model": "qwen3.8-kimiko-2","messages": [{"role": "user", "content": "Explain what this model is."}],"stream": false}'
Vision support through Ollama depends on the exported GGUF and its corresponding mmproj file. Verify that both the converted model and vision projector are supported before using image input.
[!Important] Qwen3.8 models operate in thinking mode by default, generating thinking content signified by
<think>\n...</think>\n\nbefore 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.0Please 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 analysismedium: balancing accuracy and speedlow: efficient reasoning optimizing for speed and costIn 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.
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 accordinglyexport OPENAI_BASE_URL='your-base-url'export OPENAI_API_KEY='your-api-key'
python
from openai import OpenAI# Configured by environment variablesclient = 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 lowstream=True,stream_options={"include_usage": True},)reasoning_content = ""answer_content = ""is_answering = Falseprint("\n" + "=" * 20 + "Reasoning" + "=" * 20 + "\n")for chunk in completion:if not chunk.choices:print("\nUsage:")print(chunk.usage)continuedelta = chunk.choices[0].deltaif 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_contentelif hasattr(delta, "reasoning") and delta.reasoning is not None:if not is_answering:print(delta.reasoning, end="", flush=True)reasoning_content += delta.reasoningif hasattr(delta, "content") and delta.content:if not is_answering:print("\n" + "=" * 20 + "Answer" + "=" * 20 + "\n")is_answering = Trueprint(delta.content, end="", flush=True)answer_content += delta.contentmessages.append({"role": "assistant","content": answer_content,"reasoning_content": reasoning_content,"reasoning": reasoning_content,})
python
from openai import OpenAI# Configured by environment variablesclient = 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)
python
from openai import OpenAI# Configured by environment variablesclient = 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)
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 variablesclient = 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": Falseinstead of"chat_template_kwargs": {"enable_thinking": False}.
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 variablesclient = 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": Falsedirectly instead of wrapping it inchat_template_kwargs.
To achieve optimal performance, we recommend the following settings:
Sampling Parameters: We suggest using the following sets of sampling parameters:
temperature=1.0, top_p=0.95, top_k=20, min_p=0.0, presence_penalty=0.0, repetition_penalty=1.0temperature=0.7, top_p=0.80, top_k=20, min_p=0.0, presence_penalty=1.5, repetition_penalty=1.0For 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.
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}}
For 2-3x faster inference with this model as target, retrain these draft models on your merged checkpoint (do NOT merge weights):
markdown
ash sglang --model-path ./merged_27b_output --speculative-algorithm DFLASH --speculative-draft-model-path ./draft-retrained
| IFEval inst strict |
| 82.5 |
| 86.45 |
| 87.5 |
| TBD |
| IFEval prompt loose | 83.2 | 86.69 | 87.2 | TBD |
| IFEval inst loose | 84.3 | 88.01 | 89.7 | TBD |
| VMLU val (744) | 83.5 | 86.02 | 84.8 | TBD |
presence_penaltyAdequate 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:
These settings provide the necessary capacity for complex reasoning while ensuring ample space for high-quality final deliverables.
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:
json
{"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
shell
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
shell
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
shell
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_parametersconfiguration only when processing long contexts is required. It is also recommended to modify thefactoras needed. For example, if the typical context length for your application is 524,288 tokens, it would be better to setfactoras 2.0.
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,
json
{"longest_edge": 469762048, "shortest_edge": 4096}
Alternatively, override the default values via engine startup parameters. For implementation details, refer to: vLLM / SGLang.