Qwen3.8-2.4T-A95B-FP8

De gebruikte kwantisatiemethode is fine-grained FP8-kwantisering met een blokgrootte van 128. De prestatie-indicatoren zijn nagenoeg identiek aan die van het originele model.

Voor gebruikers die op zoek zijn naar beheerde, schaalbare inferentie zonder onderhoud van de infrastructuur, is de officiële Qwen API-service beschikbaar via Qwen Cloud. In het bijzonder is Qwen3.8-Max de officiële versie gebaseerd op Qwen3.8-2.4T-A95B; deze biedt extra functies zoals visuele input, ondersteuning zonder 'denkproces', een standaard contextlengte van 1 miljoen tokens en officiële ingebouwde tools. Voor meer informatie kan men kijken naar het overzicht van Qwen3.8-Max.

Na de brede adoptie door de community van de Qwen3.5- en Qwen3.6-series, introduceren wij nu Qwen3.8, de meest capabele generatie binnen de Qwen open-model familie tot op heden. Voor het eerst wordt met Qwen3.8 een model uit de Qwen-Max-klasse openbaar beschikbaar gesteld.

Gebouwd op de architecturale basis van Qwen3.5, levert Qwen3.8 aanzienlijke verbeteringen op het gebied van coderen, professioneel werk, onderzoek en complexe agent-taken over een langere horizon. Naast het beantwoorden van moeilijkere vragen is Qwen3.8 ontworpen om complexe, meerstaps taken met grotere betrouwbaarheid tot een voltooiing te brengen.

Belangrijkste kenmerken van Qwen3.8

Qwen3.8 biedt de volgende verbeteringen:

• Kerncapaciteiten: Omvattende verbeteringen in coderen, professioneel werk, onderzoek en langdurige agent-taken.
• Agent-uitvoering: Sterkere autonome planning en een betere omgang met feedback uit de omgeving, wat leidt tot een betrouwbaardere end-to-end voltooiing van taken.
• Downstream Compatibiliteit: Bredere ondersteuning voor populaire harnesses en ontwikkeltools, waardoor integratie in bestaande stacks eenvoudiger wordt.
• Flexibele controle over het denkproces: De redeneerdiepte kan worden afgestemd met reasoningeffort, en de redeneercontext uit historische berichten wordt behouden via preservethinking.

Modeloverzicht

• Type: Causaal taalmodel (Causal Language Model)
• Trainingsfase: Pre-training & Post-training
• Totaal aantal parameters: 2,4 biljoen (2.4T), waarvan 95 miljard (95B) geactiveerd
• Hidden Dimension: 8192
• Token Embedding: 248.320 (gepaded)
• Aantal lagen: 92
• Hidden Layout: 23 × (3 × (Gated DeltaNet → MoE) → 1 × (Gated Attention → MoE))
• Gated DeltaNet:
• Aantal Linear Attention Heads: 128 voor V en 16 voor QK
• Head Dimension: 128
• Gated Attention:
• Aantal Attention Heads: 64 voor Q en 4 voor KV
• Head Dimension: 256
• Rotary Position Embedding Dimension: 64
• Mixture of Experts (MoE):
• Totaal aantal experts: 512
• Aantal geactiveerde experts: 10 Routed + 1 Shared
• Expert Intermediate Dimension: 2048
• LM Output: 248.320 (gepaded)
• MTP (Multi-Token Prediction): getraind met meerdere stappen
• Contextlengte: Natuurlijk 262.144 tokens, uitbreidbaar tot 1.010.000 tokens.

Benchmark Resultaten

Categorie / Benchmark	Opus 4.8	Fable 5	GPT 5.6 Sol (max)	Qwen3.7-Max	Qwen3.8-Max
Coding Agent
Terminal Bench 2.1	84.6	84.6	88.8	74.5	86.6
SWE-bench Pro	69.2	80.0	64.6	60.6	67.7
DeepSWE 1.1	59.0	70.0	73.0	21.6	56.6
NL2Repo-Bench	69.4	--	--	47.2	55.9
FrontierSWE	70.0	88.8	--	40.7	73.5
MLS-Bench-Lite	42.8	49.9	46.2	31.7	41.0
PaperBench	80.3	88.8	90.5	64.8	93.0
AndroidBench	69.8	84.5	74.0	56.5	75.1
QwenSWEBench	84.0	86.3	73.5	63.4	80.7
QwenQoderBench	62.7	63.1	53.8	36.8	58.4
QwenReactBench	1694	1770	1564	1538	1724
QwenSVGBench	1648	1690	1758	1499	1713
General Agent
CoWorkBench	72.3	75.9	71.5	64.6	74.8
WorkSpaceBench	66.8	68.7	65.6	61.4	67.7
JobBench	48.4	57.4	45.4	31.3	53.4
SkillsBench	65.1	70.9	73.5	61.2	70.2
Agents' Last Exam (Pass / Score)	27.0 / 45.1	-- / --	30.6 / 53.6	11.8 / 31.1	27.0 / 52.4
Automation-Bench (Pass@1)	27.2	29.1	29.7	14.2	27.3
Toolathlon Verified (Pass@1)	76.2	77.9	74.9	49.7	72.5
WideSearch	72.9	81.2	--	75.2	81.9
HLE w/ tools	57.9	64.5	58.0	53.5	56.2
General Capabilities
GPQA Diamond	92.0	92.6	94.1	92.4	92.6
HLE	45.7	53.3	47.2	41.4	43.6
IFBench	62.2	63.5	72.7	79.1	82.8
$OneMillion-Bench (expert score)	41.8	55.9	53.8	44.4	52.5
HealthBench	52.4	--	55.3	54.5	60.2
PLawBench	69.6	70.2	72.3	58.9	73.2
PRBench-Legal	52.7	57.6	57.6	48.5	57.6
PRBench-Finance	51.9	55.8	55.5	46.8	58.3
MRCR v2 256K (8-needle)	83.2	--	93.8	86.7	92.9
LongBench v2	69.1	--	67.1	65.3	66.3

Toelichtingen bij benchmarks:

1. Resultaten van Fable5 kunnen fallbacks bevatten.
2. Terminal Bench 2.1: Geëvalueerd met Claude Code (avg@10), met een timeout van 5 uur en max\_tokens=131.072. Voor andere modellen zijn de beste gepubliceerde scores gebruikt.
3. SWE-bench Pro: Geëvalueerd met de Claude Code harness, temp=1.0, top\_p=0.95 en een contextvenster van 256K.
4. DeepSWE 1.1: Geëvalueerd met Claude Code en mini-SWE-agent harnesses; Qwen3.8-Max presteerde het best op Claude Code.
5. NL2Repo-Bench: Geëvalueerd met de Claude Code harness; Bash-commando's die toegang zoeken tot specifieke repositories zijn uitgeschakeld om reward hacking te voorkomen.
6. FrontierSWE: Geëvalueerd met de Claude Code harness. Overige MEAN@5 resultaten komen van het officiële FrontierSWE leaderboard per 3 augustus 2026.
7. MLS-Bench-Lite: Geëvalueerd met Claude Code (timeout 5 uur, max\_tokens=131.072).
8. PaperBench: Geëvalueerd in BasicAgent setting onder Code-Dev mode, beoordeeld door Claude Opus 4.6.
9. AndroidBench: Geëvalueerd op de publieke subset van 95 taken (avg@3 scores).
10. QwenSWEBench: Interne coding benchmark voor software engineering capaciteiten; geëvalueerd met Claude Code harness.
11. QwenQoderBench: Interne coding benchmark voor gebruikerservaring op Qoder; geëvalueerd met Claude Code harness.
12. QwenReactBench: Interne React project building benchmark via Claude Code, tweetalig (EN/CN), 7 categorieën.
13. QwenSVGBench: Interne SVG code generatie benchmark; tweetalig (EN/CN).
14. CoWorkBench: Interne cowork benchmark voor langdurige taken in CS, finance, law en medical domeinen.
15. SkillsBench: Geëvalueerd op SkillsBench v1.1 over 87 taken.
16. Automation-Bench: Geëvalueerd op de publieke subset van 600 taken.
17. WideSearch: Geëvalueerd met Claude Code harness (externe modellen) en Qwen-Agent harness (eigen modellen).
18. $OneMillion-Bench: Geëvalueerd met gemini-3.1-pro-preview.
19. PLawBench: Geëvalueerd met gemini-3.1-pro-preview.
20. Lege cellen (--) betekenen dat scores nog niet beschikbaar of niet van toepassing zijn.

Snelstart en Implementatie

Voor een gestroomlijnde integratie raden we aan om Qwen3.8 via API's te gebruiken. De efficiëntie en doorvoer variëren per framework; gebruik daarom altijd de nieuwste versies. Voor productieomgevingen worden SGLang, vLLM of TokenSpeed aanbevolen.

Gebruik met Libraries en Frameworks

Transformers

# Gebruik een pipeline als high-level helper
from transformers import pipeline
pipe = pipeline("text-generation", model="Qwen/Qwen3.8-2.4T-A95B-FP8")
messages = [
    {"role": "user", "content": "Who are you?"},
]
pipe(messages)

# Model direct laden
from transformers import AutoTokenizer, AutoModelForCausalLM
tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen3.8-2.4T-A95B-FP8")
model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen3.8-2.4T-A95B-FP8", device_map="auto")

messages = [
    {"role": "user", "content": "Who are you?"},
]
inputs = tokenizer.apply_chat_template(
    messages,
    add_generation_prompt=True,
    tokenize=True,
    return_dict=True,
    return_tensors="pt",
).to(model.device)

outputs = model.generate(**inputs, max_new_tokens=40)
print(tokenizer.decode(outputs[0][inputs["input_ids"].shape[-1]:]))

vLLM

Installatie en serverstart:

pip install vllm
vllm serve "Qwen/Qwen3.8-2.4T-A95B-FP8"

De server aanroepen via curl (OpenAI-compatibele API):

curl -X POST "http://localhost:8000/v1/chat/completions" \
-H "Content-Type: application/json" \
--data '{
    "model": "Qwen/Qwen3.8-2.4T-A95B-FP8",
    "messages": [
        {
            "role": "user",
            "content": "What is the capital of France?"
        }
    ]
}'

Alternatief via Docker: docker model run hf.co/Qwen/Qwen3.8-2.4T-A95B-FP8

SGLang

Installatie en serverstart:

pip install sglang
python3 -m sglang.launch_server \
--model-path "Qwen/Qwen3.8-2.4T-A95B-FP8" \
--host 0.0.0.0 \
--port 30000

De server aanroepen via curl:

curl -X POST "http://localhost:30000/v1/chat/completions" \
-H "Content-Type: application/json" \
--data '{
    "model": "Qwen/Qwen3.8-2.4T-A95B-FP8",
    "messages": [
        {
            "role": "user",
            "content": "What is the capital of France?"
        }
    ]
}'

API Gebruik

Qwen3.8-2.4T-A95B is een tekstmodel dat voor alle interacties een denkmodus (thinking mode) vereist. Multimodale inputs worden niet ondersteund en het denkproces kan niet worden uitgeschakeld. Elk antwoord begint automatisch met redenering tussen <think>\n...</think>\n\n voordat de uiteindelijke output volgt.

Aanbevolen Sampling Parameters

Gebruik de volgende parameters voor generatie: temperature=1.0, topp=0.95, topk=20, minp=0.0, presencepenalty=0.0, repetition_penalty=1.0

Redeneercontrole

Qwen3.8 ondersteunt reasoning_effort om de diepte van het redeneren en de kosten te beheren:

• xhigh (standaard): voor complexe taken die grondige analyse vereisen.
• medium: balans tussen nauwkeurigheid en snelheid.
• low: efficiënt redeneren, geoptimaliseerd voor snelheid en kosten.

Daarnaast is preserve_thinking standaard ingeschakeld voor de beste resultaten.

Chat Completions API Voorbeeld

Zorg dat de OpenAI Python SDK is geïnstalleerd: pip install -U openai.

from openai import OpenAI
import os

# Configuratie via omgevingsvariabelen
client = OpenAI()

messages = [{"role": "user", "content": "Schrijf een Python-functie om twee gesorteerde linked lists samen te voegen."}]

completion = client.chat.completions.create(
    model="Qwen/Qwen3.8-2.4T-A95B-FP8",
    messages=messages,
    extra_body={
        "chat_template_kwargs": {
            "enable_thinking": True,  # standaard aan; mag niet worden uitgeschakeld
            "preserve_thinking": True, # standaard aan
        },
    },
    reasoning_effort="xhigh",
    stream=True,
    stream_options={"include_usage": True},
)

reasoning_content = ""
answer_content = ""
is_answering = False

print("\n" + "=" * 20 + " Redenering " + "=" * 20 + "\n")
for chunk in completion:
    if not chunk.choices:
        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
    if hasattr(delta, "content") and delta.content:
        if not is_answering:
            print("\n" + "=" * 20 + " Antwoord " + "=" * 20 + "\n")
            is_answering = True
        print(delta.content, end="", flush=True)
        answer_content += delta.content

Best Practices

Voor optimale prestaties raden we het volgende aan:

1. Sampling Parameters: Gebruik de bovengenoemde instellingen. Indien ondersteund door het framework kan presence_penalty worden aangepast tussen 0 en 2 om oneindige herhaling te verminderen (let op: zeer hoge waarden kunnen leiden tot taalmixing).
2. Voldoende Outputlengte: Voor agent-taken is een ruime outputlengte cruciaal voor gedetailleerde antwoorden. Binnen een context van 1M tokens adviseren we:

• Reasoning Content (intern redeneren): Maximaal 262.144 tokens.
• Final Response (uiteindelijk antwoord): Maximaal 131.072 tokens.

Citatie

Indien dit werk nuttig is, kunt u ons citeren met de volgende 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}
}