—
Kwaipilot35B-A3B paramsBF16MoE

KAT-Coder V2.5

Mesuré le 2026-08-13 avec vLLM v0.26.0. Dans le test de chat avec dix requêtes simultanées, ce profil atteint 10,44 tokens/s par utilisateur, avec en moyenne 2,01 secondes jusqu'au premier token. À 25k de contexte, cette attente moyenne monte à 28,91 secondes. Ces runs mesurent la vitesse et l'attente, pas la qualité des réponses.

—
Score d’adéquation (indicatif)
60
Throughput tok/s
70 GB
VRAM
11/11
Benches fiables
Hugging Face →·vLLM v0.26.0·DGX Spark, NVIDIA GB10, 128 GB unified memory·Mesuré avec un contexte de 128K·Dernière mesure 13 août 2026
02Vendor quality · référence uniquement

Connaissances : MMLU-Pro ; raisonnement : GPQA-Diamond ; code : LiveCodeBench v6. Chaque chiffre indique son test exact. Les autres tests et les mesures absentes ne permettent pas de score total. Ces chiffres externes ne sont pas notre propre évaluation de cette précision. Source : fiche modèle du fournisseur ↗

0/3
Couverture
—
knowledge
—
science
—
coding
03Performance · BF16

Decode throughput · total t/s · c=10

■ BF16
1k ctx BF1676 t/s
8k ctx BF1666 t/s
4k+turn BF1678 t/s
25k ctx BF1634 t/s
04Test suite · 11 benchmarks

6 tests closed-loop avec llama-benchy et 5 tests open-loop avec vllm bench serve. Seules les exécutions complètes sans échec des contrôles de cohérence sont retenues ; les tests open-loop exigent au moins 99 % de requêtes réussies. Les résultats bruts restent visibles. Déplie « view command » pour la commande reconstruite. Méthodologie →

01 · llama-benchyclosed-loop

Chat

Invite courte, réponse longue. La forme qui doit ressembler à une conversation normale ; le TTFT décide si cela paraît réactif.

pp (prompt)
1024
tg (gen)
1024
depth
0
concurrency
1 · 5 · 10
repeats
3
Tokens/sec · par utilisateur
10,4t/s
TTFT · mean
2,01s
3 repeats · mean ± stddevview command →hide command ↑ 
uvx llama-benchy==0.4.0 \
  --base-url http://localhost:8000/v1 \
  --model kat-coder-v2-5-bf16 \
  --pp 1024 \
  --tg 1024 \
  --depth 0 \
  --concurrency 1 5 10 \
  --runs 3 \
  --latency-mode generation \
  --format md
02 · llama-benchyclosed-loop

RAG · contexte 8k

Contexte moyen, quelques fragments de documents avec une réponse de longueur normale. Montre le coût du préremplissage sans heurter le mur.

pp (prompt)
8192
tg (gen)
512
depth
0
concurrency
5 · 10 · 20
repeats
3
Tokens/sec · par utilisateur
8,4t/s
TTFT · mean
9,45s
3 repeats · mean ± stddevview command →hide command ↑ 
uvx llama-benchy==0.4.0 \
  --base-url http://localhost:8000/v1 \
  --model kat-coder-v2-5-bf16 \
  --pp 8192 \
  --tg 512 \
  --depth 0 \
  --concurrency 5 10 20 \
  --runs 3 \
  --latency-mode generation \
  --format md
03 · llama-benchyclosed-loop

Sortie longue et agents

Instruction courte, beaucoup de sortie. Génération de code, rapports ou sorties structurées d'agents. Test de résistance du débit de décodage.

pp (prompt)
256
tg (gen)
4096
depth
0
concurrency
1 · 5 · 10
repeats
3
Tokens/sec · par utilisateur
10,6t/s
TTFT · mean
739ms
3 repeats · mean ± stddevview command →hide command ↑ 
uvx llama-benchy==0.4.0 \
  --base-url http://localhost:8000/v1 \
  --model kat-coder-v2-5-bf16 \
  --pp 256 \
  --tg 4096 \
  --depth 0 \
  --concurrency 1 5 10 \
  --runs 3 \
  --latency-mode generation \
  --format md
04 · llama-benchyclosed-loop

Travail de bureau multi-tours

Cinq tours par conversation, dix conversations en parallèle. Proche de l'usage réel d'une équipe, avec un contexte qui grandit à chaque tour.

pp (prompt)
2048
tg (gen)
512
depth
4
concurrency
1 · 5 · 10
repeats
3
Tokens/sec · par utilisateur
9,4t/s
TTFT · mean
3,07s
3 repeats · mean ± stddevview command →hide command ↑ 
uvx llama-benchy==0.4.0 \
  --base-url http://localhost:8000/v1 \
  --model kat-coder-v2-5-bf16 \
  --pp 2048 \
  --tg 512 \
  --depth 4 \
  --concurrency 1 5 10 \
  --runs 3 \
  --latency-mode generation \
  --format md
05 · llama-benchyclosed-loop

Grand contexte · 25k

Test de résistance avec de grandes invites. Pas forcément du matériel de chat, mais exactement là où le mur du préremplissage apparaît et où le TTFT s'effondre.

pp (prompt)
4096 · 8192 · 16384 · 25000
tg (gen)
256
depth
0
concurrency
1 · 5 · 10
repeats
3
Tokens/sec · par utilisateur
5,4t/s
TTFT · mean
28,91s
3 repeats · mean ± stddevview command →hide command ↑ 
uvx llama-benchy==0.4.0 \
  --base-url http://localhost:8000/v1 \
  --model kat-coder-v2-5-bf16 \
  --pp 4096 8192 16384 25000 \
  --tg 256 \
  --depth 0 \
  --concurrency 1 5 10 \
  --runs 3 \
  --latency-mode generation \
  --format md
06 · llama-benchyclosed-loop

Concurrence sous pression

Contexte de 25k avec vingt requêtes simultanées. Cinq et dix sont déjà couverts par le test 05 ; vingt montre où l'ordonnanceur abandonne.

pp (prompt)
25000
tg (gen)
256
depth
0
concurrency
20
repeats
3
Tokens/sec · par utilisateur
3,5t/s
TTFT · mean
54,14s
3 repeats · mean ± stddevview command →hide command ↑ 
uvx llama-benchy==0.4.0 \
  --base-url http://localhost:8000/v1 \
  --model kat-coder-v2-5-bf16 \
  --pp 25000 \
  --tg 256 \
  --depth 0 \
  --concurrency 20 \
  --runs 3 \
  --latency-mode generation \
  --format md
07 · vllm bench serveopen-loop

Référence de bureau réaliste

Jeu de données aléatoire, 4000 tokens en entrée et 500 en sortie, taux d'arrivée 0,3 avec une irrégularité de 0,7. Un bureau tranquille.

dataset
random
input / output
4000 / 500
rate (req/s)
0.3
prompts
200
burstiness
0.7
Tokens/sec · par utilisateur
25,6t/s
TTFT · p50
1,62s
Request success 100% · Inclus
200 prompts · seed 42view command →hide command ↑ 
docker exec vllm-bench vllm bench serve \
  --backend openai-chat \
  --base-url http://localhost:8000 \
  --endpoint /v1/chat/completions \
  --model Kwaipilot/KAT-Coder-V2.5-Dev \
  --tokenizer Kwaipilot/KAT-Coder-V2.5-Dev \
  --served-model-name kat-coder-v2-5-bf16 \
  --dataset-name random \
  --random-input-len 4000 \
  --random-output-len 500 \
  --random-range-ratio 0.9 \
  --num-prompts 200 \
  --request-rate 0.3 \
  --burstiness 0.7 \
  --percentile-metrics ttft,tpot,itl,e2el \
  --metric-percentiles 50,90,95,99 \
  --seed 42 \
  --save-result \
  --result-dir /tmp \
  --result-filename 07-office-baseline.json
08 · vllm bench serveopen-loop

Vraies conversations · ShareGPT

ShareGPT V3, en moyenne 228 tokens par tour, variant naturellement selon la conversation. Ce que font les vrais utilisateurs, pas une distribution synthétique.

dataset
sharegpt
rate (req/s)
0.3
prompts
250
burstiness
0.7
Tokens/sec · par utilisateur
8,1t/s
TTFT · p50
386ms
Request success 100% · Inclus
250 prompts · seed 42view command →hide command ↑ 
docker exec vllm-bench vllm bench serve \
  --backend openai-chat \
  --base-url http://localhost:8000 \
  --endpoint /v1/chat/completions \
  --model Kwaipilot/KAT-Coder-V2.5-Dev \
  --tokenizer Kwaipilot/KAT-Coder-V2.5-Dev \
  --served-model-name kat-coder-v2-5-bf16 \
  --dataset-name sharegpt \
  --dataset-path /tmp/ShareGPT_V3.json \
  --num-prompts 250 \
  --request-rate 0.3 \
  --burstiness 0.7 \
  --percentile-metrics ttft,tpot,itl,e2el \
  --metric-percentiles 50,90,95,99 \
  --seed 42 \
  --save-result \
  --result-dir /tmp \
  --result-filename 08-sharegpt.json
09 · vllm bench serveopen-loop

Charge de raisonnement

Longues chaînes de pensée, 1k en entrée et 4k en sortie, taux d'arrivée lent de 0,2 car chaque requête coûte beaucoup de budget de décodage. Vérifie si le TTFT reste stable.

dataset
random
input / output
1024 / 4096
rate (req/s)
0.2
prompts
50
burstiness
1
Tokens/sec · par utilisateur
3,9t/s
TTFT · p50
712ms
Request success 100% · Inclus
50 prompts · seed 42view command →hide command ↑ 
docker exec vllm-bench vllm bench serve \
  --backend openai-chat \
  --base-url http://localhost:8000 \
  --endpoint /v1/chat/completions \
  --model Kwaipilot/KAT-Coder-V2.5-Dev \
  --tokenizer Kwaipilot/KAT-Coder-V2.5-Dev \
  --served-model-name kat-coder-v2-5-bf16 \
  --dataset-name random \
  --random-input-len 1024 \
  --random-output-len 4096 \
  --random-range-ratio 0.9 \
  --num-prompts 50 \
  --request-rate 0.2 \
  --burstiness 1.0 \
  --percentile-metrics ttft,tpot,itl,e2el \
  --metric-percentiles 50,90,95,99 \
  --seed 42 \
  --save-result \
  --result-dir /tmp \
  --result-filename 09-reasoning.json
10 · vllm bench serveopen-loop

Pic du lundi matin

Aléatoire, 4000 en entrée et 500 en sortie, taux d'arrivée de 1,5 par seconde avec une irrégularité de 1,0 et 25 en parallèle au maximum. Un flux de requêtes indépendant et soutenu.

dataset
random
input / output
4000 / 500
rate (req/s)
1.5
prompts
300
burstiness
1
max parallel
25
Tokens/sec · par utilisateur
37,4t/s
TTFT · p50
1,37s
Request success 100% · Inclus
300 prompts · seed 42view command →hide command ↑ 
docker exec vllm-bench vllm bench serve \
  --backend openai-chat \
  --base-url http://localhost:8000 \
  --endpoint /v1/chat/completions \
  --model Kwaipilot/KAT-Coder-V2.5-Dev \
  --tokenizer Kwaipilot/KAT-Coder-V2.5-Dev \
  --served-model-name kat-coder-v2-5-bf16 \
  --dataset-name random \
  --random-input-len 4000 \
  --random-output-len 500 \
  --random-range-ratio 0.9 \
  --num-prompts 300 \
  --request-rate 1.5 \
  --burstiness 1.0 \
  --max-concurrency 25 \
  --percentile-metrics ttft,tpot,itl,e2el \
  --metric-percentiles 50,90,95,99 \
  --seed 42 \
  --save-result \
  --result-dir /tmp \
  --result-filename 10-monday-peak.json
11 · vllm bench serveopen-loop

Capacité · balayage de débit

Six taux d'arrivée croissants, de 0,1 à 1,0 requête par seconde. À chaque palier, on vérifie si le TTFT p95 reste sous le seuil.

dataset
random
input / output
4000 / 500
rates (req/s)
0.1 · 0.2 · 0.3 · 0.5 · 0.7 · 1.0
prompts
100 · 100 · 100 · 125 · 175 · 250
burstiness
0.7
Req/s · TTFT < 5s
0,32req/s
Req/s · TTFT < 10s
0,47req/s
Request success 100% · Inclus
6 rates · seed 42view command →hide command ↑ 
# 0.1 req/s
docker exec vllm-bench vllm bench serve \
  --backend openai-chat \
  --base-url http://localhost:8000 \
  --endpoint /v1/chat/completions \
  --model Kwaipilot/KAT-Coder-V2.5-Dev \
  --tokenizer Kwaipilot/KAT-Coder-V2.5-Dev \
  --served-model-name kat-coder-v2-5-bf16 \
  --dataset-name random \
  --random-input-len 4000 \
  --random-output-len 500 \
  --random-range-ratio 0.9 \
  --num-prompts 100 \
  --request-rate 0.1 \
  --burstiness 0.7 \
  --percentile-metrics ttft,tpot,itl,e2el \
  --metric-percentiles 50,90,95,99 \
  --seed 42 \
  --save-result \
  --result-dir /tmp \
  --result-filename 11-rate-sweep-0.1.json

# 0.2 req/s
docker exec vllm-bench vllm bench serve \
  --backend openai-chat \
  --base-url http://localhost:8000 \
  --endpoint /v1/chat/completions \
  --model Kwaipilot/KAT-Coder-V2.5-Dev \
  --tokenizer Kwaipilot/KAT-Coder-V2.5-Dev \
  --served-model-name kat-coder-v2-5-bf16 \
  --dataset-name random \
  --random-input-len 4000 \
  --random-output-len 500 \
  --random-range-ratio 0.9 \
  --num-prompts 100 \
  --request-rate 0.2 \
  --burstiness 0.7 \
  --percentile-metrics ttft,tpot,itl,e2el \
  --metric-percentiles 50,90,95,99 \
  --seed 42 \
  --save-result \
  --result-dir /tmp \
  --result-filename 11-rate-sweep-0.2.json

# 0.3 req/s
docker exec vllm-bench vllm bench serve \
  --backend openai-chat \
  --base-url http://localhost:8000 \
  --endpoint /v1/chat/completions \
  --model Kwaipilot/KAT-Coder-V2.5-Dev \
  --tokenizer Kwaipilot/KAT-Coder-V2.5-Dev \
  --served-model-name kat-coder-v2-5-bf16 \
  --dataset-name random \
  --random-input-len 4000 \
  --random-output-len 500 \
  --random-range-ratio 0.9 \
  --num-prompts 100 \
  --request-rate 0.3 \
  --burstiness 0.7 \
  --percentile-metrics ttft,tpot,itl,e2el \
  --metric-percentiles 50,90,95,99 \
  --seed 42 \
  --save-result \
  --result-dir /tmp \
  --result-filename 11-rate-sweep-0.3.json

# 0.5 req/s
docker exec vllm-bench vllm bench serve \
  --backend openai-chat \
  --base-url http://localhost:8000 \
  --endpoint /v1/chat/completions \
  --model Kwaipilot/KAT-Coder-V2.5-Dev \
  --tokenizer Kwaipilot/KAT-Coder-V2.5-Dev \
  --served-model-name kat-coder-v2-5-bf16 \
  --dataset-name random \
  --random-input-len 4000 \
  --random-output-len 500 \
  --random-range-ratio 0.9 \
  --num-prompts 125 \
  --request-rate 0.5 \
  --burstiness 0.7 \
  --percentile-metrics ttft,tpot,itl,e2el \
  --metric-percentiles 50,90,95,99 \
  --seed 42 \
  --save-result \
  --result-dir /tmp \
  --result-filename 11-rate-sweep-0.5.json

# 0.7 req/s
docker exec vllm-bench vllm bench serve \
  --backend openai-chat \
  --base-url http://localhost:8000 \
  --endpoint /v1/chat/completions \
  --model Kwaipilot/KAT-Coder-V2.5-Dev \
  --tokenizer Kwaipilot/KAT-Coder-V2.5-Dev \
  --served-model-name kat-coder-v2-5-bf16 \
  --dataset-name random \
  --random-input-len 4000 \
  --random-output-len 500 \
  --random-range-ratio 0.9 \
  --num-prompts 175 \
  --request-rate 0.7 \
  --burstiness 0.7 \
  --percentile-metrics ttft,tpot,itl,e2el \
  --metric-percentiles 50,90,95,99 \
  --seed 42 \
  --save-result \
  --result-dir /tmp \
  --result-filename 11-rate-sweep-0.7.json

# 1.0 req/s
docker exec vllm-bench vllm bench serve \
  --backend openai-chat \
  --base-url http://localhost:8000 \
  --endpoint /v1/chat/completions \
  --model Kwaipilot/KAT-Coder-V2.5-Dev \
  --tokenizer Kwaipilot/KAT-Coder-V2.5-Dev \
  --served-model-name kat-coder-v2-5-bf16 \
  --dataset-name random \
  --random-input-len 4000 \
  --random-output-len 500 \
  --random-range-ratio 0.9 \
  --num-prompts 250 \
  --request-rate 1.0 \
  --burstiness 0.7 \
  --percentile-metrics ttft,tpot,itl,e2el \
  --metric-percentiles 50,90,95,99 \
  --seed 42 \
  --save-result \
  --result-dir /tmp \
  --result-filename 11-rate-sweep-1.0.json
05Notes sur cette exécution

Chat

Chat avec dix requêtes simultanées

Avec 1024 tokens d'entrée et 1024 tokens de sortie à dix requêtes simultanées, je mesure en moyenne 10,44 tokens/s par utilisateur. L'attente moyenne du premier token est de 2,01 secondes.

Contexte long

Attente à 25k de contexte

Avec 25000 tokens d'entrée et 256 tokens de sortie à dix requêtes simultanées, l'attente moyenne du premier token est de 28,91 secondes. Ensuite le modèle génère en moyenne 5,43 tokens/s par utilisateur. La mesure seule ne montre pas si la mémoire, le traitement du prompt ou l'ordonnancement cause le retard.

Charge de pointe

Requêtes et attente en charge de pointe

Le run traite 0,22 requêtes/s pour un taux d'arrivée configuré de 1,5 requêtes/s. 300 des 300 requêtes aboutissent. L'attente p95 du premier token est de 3,97 secondes.

Couverture des mesures

Quelles mesures comptent

11 des 11 tests ont une mesure qui compte selon les règles actuelles de l'Arena. Le contrôle de cohérence est réussi. Il s'agit d'un contrôle sur une courte réponse générée, pas d'une évaluation de fond des tâches du benchmark.

Plus de chiffres ?
Lis l’article complet.

RunDonnées source et métadonnées→WeightsHugging Face→RetourVers l'arena→
MarkdownSource JSON
Explication