Qwen3.8-2.4T-A95B

Voor gebruikers die op zoek zijn naar beheerde, schaalbare inferentie zonder onderhoud van de infrastructuur, wordt de officiële Qwen API-service aangeboden via Qwen Cloud. In het bijzonder is Qwen3.8-Max de officiële versie gebaseerd op Qwen3.8-2.4T-A95B, met extra functies zoals vision-input, ondersteuning zonder "denkproces" (non-thinking), een standaard contextlengte van 1 miljoen tokens en officiële ingebouwde tools. Voor meer informatie kan men terecht bij het overzicht van Qwen3.8-Max.

Na de brede adoptie door de community van de Qwen3.5- en Qwen3.6-series, introduceren we Qwen3.8, de tot nu toe meest capabele generatie in de familie van Qwen open-modellen. Voor het eerst wordt met Qwen3.8 een model van de Qwen-Max-klasse open released.

Gebouwd op het architecturale fundament van Qwen3.5, biedt Qwen3.8 aanzienlijke verbeteringen op het gebied van programmeren, professioneel werk, onderzoek en complexe agent-taken over een langere periode. 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 bevat de volgende verbeteringen:

• Kerncapaciteiten: Omvattende verbeteringen in programmeren, professioneel werk, onderzoek en langdurige agent-taken.
• Uitvoering van agents: Sterkere autonome planning en een betere omgang met feedback uit de omgeving, wat leidt tot een betrouwbaardere end-to-end voltooiing van taken.
• Downstreamcompatibiliteit: Bredere ondersteuning voor populaire harnesses en ontwikkeltools, waardoor integratie in bestaande stacks eenvoudiger wordt.
• Flexibele besturing van het denkproces: De diepte van het redeneren kan worden afgestemd met reasoningeffort, en de redeneercontext uit eerdere berichten wordt behouden via preservethinking.

Modeloverzicht

• Type: Causaal taalmodel (Causal Language Model)
• Trainingsfase: Pre-training & Post-training

Taalmodel specificaties

• Aantal parameters: 2,4T in totaal, waarvan 95B geactiveerd
• Verborgen dimensie (Hidden Dimension): 8192
• Token Embedding: 248.320 (gepadded)
• Aantal lagen: 92
• Verborgen layout: 23 × (3 × (Gated DeltaNet → MoE) → 1 × (Gated Attention → MoE))

Gated DeltaNet:

• Aantal lineaire aandachtskoppen: 128 voor V en 16 voor QK
• Kopdimensie (Head Dimension): 128

Gated Attention:

• Aantal aandachtskoppen: 64 voor Q en 4 voor KV
• Kopdimensie (Head Dimension): 256
• Rotary Position Embedding dimensie: 64

Mixture of Experts (MoE):

• Aantal experts: 512
• Aantal geactiveerde experts: 10 Routed + 1 Shared
• Expert Intermediate Dimension: 2048

Overige details:

• LM Output: 248.320 (gepadded)
• MTP (Multi-Token Prediction): getraind met meerdere stappen
• Contextlengte: 262.144 tokens native, uitbreidbaar tot 1.010.000 tokens.

Benchmarkresultaten

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), gebruikmakend van een timeout van 5 uur en max_tokens=131,072. Voor alle andere modellen rapporteren we de beste gepubliceerde score over harnesses: Claude Opus 4.8 en Claude Fable 5 via Terminus 2 van Artificial Analysis; GPT-5.6 Sol via Codex.
3. SWE-bench Pro: Geëvalueerd met de Claude Code harness, temp=1.0, top_p=0.95, en een contextvenster van 256K. Problematische taken zijn gecorrigeerd en alle baselines zijn geëvalueerd op de verfijnde benchmark.
4. DeepSWE 1.1: Geëvalueerd met de Claude Code en mini-SWE-agent harnesses, temp=1.0, top_p=0.95, en een contextvenster van 256K. De hoogste score tussen beide harnesses wordt gerapporteerd; Qwen3.8-Max presteert het best op Claude Code.
5. NL2Repo-Bench: Geëvalueerd met de Claude Code harness. Om reward hacking te voorkomen, zijn Bash-commando's die toegang proberen te krijgen tot de specifieke repository (zoals pip download, pip install en git clone) uitgeschakeld.
6. FrontierSWE: Geëvalueerd met de Claude Code harness. Alle andere beschikbare MEAN@5 resultaten zijn afkomstig van het officiële FrontierSWE leaderboard per 3 augustus 2026. Dominantie-scores zijn opnieuw berekend vanuit raw scores. "--" geeft aan dat er geen officieel MEAN@5 resultaat beschikbaar was op die datum.
7. MLS-Bench-Lite: Geëvalueerd met Claude Code met een timeout van 5 uur en max_tokens=131,072. Scores voor andere modellen zijn afkomstig van het officiële leaderboard.
8. PaperBench: Geëvalueerd in de BasicAgent setting onder Code-Dev modus, beoordeeld door Claude Opus 4.6, en gemiddeld over 3 runs (max 12 uur per run).
9. AndroidBench: Geëvalueerd op de publieke subset van 95 taken; rapporteert avg@3 scores.
10. QwenSWEBench: Interne coding benchmark om software engineering capaciteiten te evalueren. Geëvalueerd met de Claude Code harness. Rapporteert avg@3 met een timeout van 8 uur, max_tokens=32,768, temperatuur=1.0 en een contextvenster van 256K tokens.
11. QwenQoderBench: Interne coding benchmark om gebruikerservaring op Qoder te evalueren. Geëvalueerd met de Claude Code harness. Rapporteert avg@5 met een timeout van 6 uur, max_tokens=32,768, temperatuur=1.0 en een contextvenster van 256K tokens.
12. QwenReactBench: Interne benchmark voor het bouwen van React-projecten met Claude Code als harness; tweetalig (EN/CN), 7 categorieën; auto-render + multimodale judge; BT/Elo rating.
13. QwenSVGBench: Interne benchmark voor SVG-codegeneratie; tweetalig (EN/CN), auto-render + multimodale judge; BT/Elo rating.
14. CoWorkBench: Interne cowork benchmark voor het evalueren van langdurige taken in domeinen zoals computerwetenschappen, finance, recht en medische productiviteit.
15. SkillsBench: Geëvalueerd op de publieke SkillsBench v1.1 benchmark over 87 taken; rapporteert de gemiddelde score over drie runs per taak. Opus 4.8 en Fable 5 zijn geëvalueerd op Claude Code; GPT-5.6 Sol op Codex; de Qwen-serie op OpenCode.
16. Automation-Bench: Geëvalueerd op de publieke subset van 600 taken.
17. WideSearch: Geëvalueerd met de Claude Code harness voor externe modellen en de Qwen-Agent harness voor eigen modellen; rapporteert de gemiddelde item-F1 over vier runs.
18. $OneMillion-Bench: Geëvalueerd met behulp van gemini-3.1-pro-preview.
19. PLawBench: Geëvalueerd met behulp van gemini-3.1-pro-preview.
20. Lege cellen (--): Scores zijn nog niet beschikbaar of niet van toepassing.

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 aanzienlijk per framework; gebruik daarom de nieuwste versies voor optimale prestaties. Voor productieomgevingen of scenario's met hoge doorvoer worden dedicated serving engines zoals SGLang, vLLM of TokenSpeed aanbevolen.

Implementatie via populaire frameworks:

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

Voorbeeldgebruik met Transformers (Python):

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

# Of het model direct laden
from transformers import AutoTokenizer, AutoModelForCausalLM
tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen3.8-2.4T-A95B")
model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen3.8-2.4T-A95B", 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]:]))

Voorbeeldgebruik met vLLM:

# Installeer vLLM via pip
pip install vllm

# Start de vLLM server
vllm serve "Qwen/Qwen3.8-2.4T-A95B"

# Roep de server aan 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",
    "messages": [
        {
            "role": "user",
            "content": "Wat is de hoofdstad van Frankrijk?"
        }
    ]
}'

Voorbeeldgebruik met SGLang:

# Installeer SGLang via pip
pip install sglang

# Start de SGLang server
python3 -m sglang.launch_server \
--model-path "Qwen/Qwen3.8-2.4T-A95B" \
--host 0.0.0.0 \
--port 30000

# Roep de server aan via curl (OpenAI-compatibele API)
curl -X POST "http://localhost:30000/v1/chat/completions" \
-H "Content-Type: application/json" \
--data '{
    "model": "Qwen/Qwen3.8-2.4T-A95B",
    "messages": [
        {
            "role": "user",
            "content": "Wat is de hoofdstad van Frankrijk?"
        }
    ]
}'

API-gebruik

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

Aanbevolen sampling parameters:

temperature=1.0, topp=0.95, topk=20, minp=0.0, presencepenalty=0.0, repetition_penalty=1.0

Besturing van het redeneren (reasoning_effort)

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

• xhigh (standaard): Voor complexe taken die een 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 alle workloads.

Chat Completions API Voorbeeld (Python)

from openai import OpenAI
import os

# Configuraties 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",
    messages=messages,
    extra_body={
        "chat_template_kwargs": {
            "enable_thinking": True,  # Standaard aan; mag niet worden uitgeschakeld
            "preserve_thinking": True, # Standaard aan
        },
    },
    reasoning_effort="xhigh",  # Opties: xhigh, medium, low
    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:
        if hasattr(chunk, "usage"):
            print("\nGebruik:", 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

    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

Let op: Bij gebruik van API's van Qwen Cloud dient men extrabody={"enablethinking": True, "preservethinking": True} te gebruiken in plaats van de genestte chattemplate_kwargs structuur.

Best Practices

Voor optimale prestaties raden we de volgende instellingen aan:

Sampling Parameters

Gebruik de bovengenoemde set parameters. Voor frameworks die dit ondersteunen, kan presence_penalty worden aangepast tussen 0 en 2 om oneindige herhaling te verminderen. Let op dat een hogere waarde soms kan leiden tot taalmixing en een lichte afname in modelprestaties.

Voldoende outputlengte

Om de prestaties bij agent-taken te optimaliseren, is het essentieel om voldoende outputlengte toe te wijzen. Voor frameworks die aparte limieten ondersteunen voor interne redenering en finale outputs (binnen de 1M contextlengte), adviseren we:

• Redeneerinhoud (Reasoning Content): Maximaal 262.144 tokens.
• Definitief antwoord (Final Response): 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}
}