# Qwen3.8-Flash-Next sur le DGX Spark de CARouter : de meilleures réponses, mais dix fois plus d'attente

> L'aperçu de l'architecture Qwen4 de Qwen domine les palmarès de codage, et sa plus petite version servable pèse 125,9 Gio face à une machine qui en compte 121,6 au total. 38 % de son poids est une table de correspondance : il tourne donc quand même - diffusé depuis le SSD, sur un moteur rapiécé, seul sur la machine. Il est environ trois fois plus lent, tient le quart des conversations et écrit trois fois et demie plus de tokens par problème. Il code probablement mieux que ce que nous servons, et sur ce matériel cet avantage coûte 13 minutes par réponse.

- Publié : 2026-08-29
- Auteur : Flavien Berwick
- Catégorie : Recherche
- Page web : https://carouter.ai/fr/blog/qwen3-8-flash-next-ten-times-the-wait
- En anglais : https://carouter.ai/blog/qwen3-8-flash-next-ten-times-the-wait.md
- Traduit de l'anglais par une IA.

![176 milliards de paramètres sur une machine de bureau : il entre en lisant 38 % de lui-même depuis le disque, et coûte 13 minutes par réponse et 4,1 fois moins de sessions pour résoudre un problème de plus sur quarante.](https://carouter.ai/blog/qwen3-8-flash-next-ten-times-the-wait/illustration.png)

Qwen a publié Qwen3.8-Flash-Next le 26 août, un premier aperçu de l'architecture sur laquelle reposera la famille Qwen4, et il s'est hissé d'emblée en tête des palmarès de codage : 91,9 sur LiveCodeBench v6 contre 80,4 pour le modèle que fait tourner notre propre point d'accès de codage. Trois jours plus tard, nous le servions sur la machine de bureau qui sert CARouter Cloud, et nous ne l'avons pas gardé. Voici tous les chiffres que nous avons mesurés, et ce qu'ils coûtent.

[Le billet précédent : pourquoi le point d'accès de codage fait tourner Qwen3.6 35B-A3B, un modèle plus ancien et moins bien classé, plutôt que Qwen3.8 27B.](https://carouter.ai/fr/blog/qwen3-6-35b-a3b-instead-of-qwen3-8-27b)

## En bref

- **Il n'entre pas.** La plus petite version que nous puissions servir pèse 125,9 Gio. La machine dispose de 121,6 Gio de mémoire au total. C'est le premier modèle que nous examinons qui soit plus gros que l'ordinateur, avant même d'avoir stocké un seul token de conversation.
- **38 % de son poids n'est pas un modèle.** C'est une table de correspondance : 20 000 000 de lignes de plongements de n-grammes, 51,2 milliards de paramètres, 47,7 Gio. Un token en touche 16 lignes. Diffusez-les depuis le SSD au lieu de les garder en mémoire et ce qui doit rester résident tombe à 78,2 Gio, ce qui entre.
- **Le nombre de paramètres annoncé l'omet.** La fiche du modèle annonce 125 milliards. Les poids en contiennent 180 milliards. La différence, c'est cette table, plus la tête de brouillon et la tour de vision, toutes comptées à part.
- **Il est environ trois fois plus lent.** 21,3 tokens par seconde sur 1 flux contre 62,2, et 129,8 contre 367,2 avec 16 flux simultanés. Le préremplissage est 3,7 fois plus lent. Il tient le quart des conversations simultanées de 262K tokens : 1,7 contre 7,0.
- **Il code probablement mieux.** Sur les 40 problèmes qu'il a terminés dans un budget de 32 768 tokens, il en a résolu 29, contre 27 pour le modèle que nous servons et 26 pour celui d'avant. Il a dépassé le budget sur les 10 autres. Aucun des deux écarts n'est statistiquement significatif.
- **Mais l'attente est dix fois plus longue.** Il écrit 16 751 tokens par problème là où le modèle en place en écrit 4 738. À sa propre vitesse de décodage, cela donne une réponse de 13 minutes contre 76 secondes, pour au mieux 1 problème résolu de plus sur 40.

## Un modèle plus gros que l'ordinateur

Le point d'accès auto-hébergé de CARouter Cloud tourne sur un seul ASUS Ascent GX10, une machine de bureau de classe DGX Spark : une puce GB10 avec 128 Go de mémoire partagée entre le processeur et la partie graphique, dont 121,6 Gio réellement adressables. Chaque modèle que nous avons mis en service devait y entrer, aux côtés des 2 modèles de plongement et du reclasseur que le produit sert également.

Qwen3.8-Flash-Next n'y entre pas. 9 personnes différentes en avaient publié des versions quantifiées en 72 heures, et nous les avons toutes vérifiées : la plus petite que nous puissions réellement servir pèse 125,9 Gio de poids. C'est 4,3 Gio de plus que ce que contient la machine entière, avant le système d'exploitation, avant le moteur d'inférence, avant d'avoir stocké un seul mot de la conversation de qui que ce soit.

![Le checkpoint publié pèse 125,9 Gio face à une machine de 121,6 Gio. Diffuser la table de n-grammes de 47,7 Gio depuis le SSD laisse 78,2 Gio résidents, ce qui entre.](https://carouter.ai/blog/qwen3-8-flash-next-ten-times-the-wait/02-bigger-than-the-box.png)

Normalement l'histoire s'arrête là, et notre procédure de présélection est conçue pour y mettre fin en 10 minutes environ, à partir des métadonnées publiques, sans rien télécharger. Ce qui a valu la peine de continuer ici, c'est d'avoir lu la liste réelle des tenseurs du fichier plutôt que la fiche du modèle.

La fiche annonce 125 milliards de paramètres. Les poids en contiennent 180 milliards. L'écart tient dans une énorme table de correspondance - les plongements de n-grammes, exactement 20 000 000 de lignes de 2 560 nombres chacune, 51,2 milliards de paramètres et 47,7 Gio même après que tous les quantificateurs en circulation s'y sont essayés, et pas un seul ne l'a comprimée sous les 8 bits. Elle représente 38 % du fichier. Ajoutez la tête de brouillon et la tour de vision, elles aussi comptées hors du chiffre annoncé, et 125 milliards deviennent 180 milliards.

Une table de correspondance n'est pas une multiplication de matrices. Produire un token touche 16 de ces 20 000 000 de lignes, environ 2,5 Ko. Elle n'a donc pas besoin d'être en mémoire du tout : elle peut rester sur le SSD et être lue au besoin. Quelqu'un l'avait déjà fait - un projet public qui corrige le moteur officiel pour projeter la table en mémoire depuis le disque - et avec lui les poids résidents tombent à 78,2 Gio et le modèle tourne sur une seule machine, seul.

## Ce qu'il a fallu pour le faire tourner tout court

6 correctifs par-dessus l'image officielle, aucun de nous : la table projetée en mémoire, deux corrections pour les noyaux d'attention linéaire sur cette puce précise, une protection contre une course à la copie d'état, une correction du cache de préfixes qui restaurait silencieusement un état entièrement nul à chaque succès de cache, et le remplacement d'un noyau d'attention creuse qui renvoie des réponses différentes à la même question. Le moteur lui-même n'est pas une version publiée - c'est une compilation issue d'une branche, parce que l'architecture est trop récente pour figurer dans une version publiée, y compris celle que nous épinglons.

Il ne peut pas non plus partager la machine. Notre point d'accès fait normalement tourner 4 services à la fois : le modèle de codage, 2 modèles de plongement et un reclasseur. Qwen3.8-Flash-Next prend la machine entière. Chaque mesure ci-dessous a été prise avec le reste de l'inférence du produit à l'arrêt.

## Le débit

Nous avons lancé le même banc d'essai que sur tout le reste, sans le modifier : la même consigne, les mêmes 20 secondes de mise en train et 40 secondes de fenêtre de mesure, les mêmes compteurs lus depuis le moteur lui-même.

![Débit de décodage à 1, 2, 4, 8 et 16 flux. Qwen3.6 35B-A3B atteint 62, 115, 181, 263 et 367 tokens par seconde ; Qwen3.8-Flash-Next atteint 21, 39, 54, 88 et 130.](https://carouter.ai/blog/qwen3-8-flash-next-ten-times-the-wait/01-decode-by-streams.png)

Entre 2,8 et 3,4 fois plus lent à tous les niveaux de simultanéité, 3,7 fois plus lent à lire une consigne, et tenant 1,7 conversation de pleine longueur à la fois là où le modèle que nous servons en tient 7,0. Ce qui rend le résultat pire qu'il n'y paraît, c'est le handicap : Qwen3.8-Flash-Next tournait avec du décodage spéculatif - une tête de brouillon intégrée à ses propres poids, acceptant 51 % de ses suppositions et livrant 2,02 tokens par étape - sur le noyau rapide de cette puce. Le modèle qui l'a battu ne dispose d'aucun modèle brouillon et tourne sur un noyau de repli que nous n'avons jamais réussi à remplacer.

## La note de codage

50 problèmes de codage, les mêmes 50 sur lesquels nous notons chaque modèle, exécutés à l'identique : mêmes problèmes, même budget, mêmes réglages, un modèle après l'autre sur la même machine.

La première chose que l'essai mesure n'est pas la qualité, c'est la longueur. Flash-Next est un modèle de raisonnement et il écrit 16 751 tokens sortants par problème, contre 4 738 pour le modèle que nous servons. Notre budget était de 32 768 tokens, et il a dépassé ce plafond sur 10 des 50 problèmes - coupé en pleine réponse, avec zéro à chaque fois. Ce ne sont pas de mauvaises réponses : l'ensemble comparable est donc celui des 40 qu'il a terminés dans le budget.

Sur ces 40, c'est lui qui arrive en tête : 29 résolus, contre 27 pour le modèle que nous servons et 26 pour celui d'avant. C'est le même ordre que les palmarès publics, et aucun des deux écarts n'est statistiquement significatif - détecter l'écart de 11,5 points annoncé par les palmarès demanderait environ 88 problèmes appariés. À lire comme compatible avec l'hypothèse que Flash-Next code mieux, et comme un échantillon trop petit pour la démontrer.

Le taux de dépassement est un résultat à part entière, et sans doute celui qui vous concernera le plus : 20 % des problèmes de codage ordinaires demandent à ce modèle plus de 32 768 tokens. Quel que soit le budget que vous fixez, il l'atteindra plus souvent que les modèles dont vous avez l'habitude, et une réponse tronquée est pire qu'une réponse lente.

## Ce que l'on attend vraiment

Le bavardage n'est pourtant pas un artefact de notre banc d'essai. C'est le produit.

![Par problème de codage, Qwen3.6 35B-A3B écrit 4 738 tokens et répond en environ 76 secondes ; Qwen3.8-Flash-Next en écrit 16 751 et prend environ 13 minutes.](https://carouter.ai/blog/qwen3-8-flash-next-ten-times-the-wait/03-the-answer-you-wait-for.png)

3,5x les tokens, au tiers de la vitesse, cela fait 10x l'attente. Soixante-seize secondes deviennent 13 minutes, pour une réponse au mieux meilleure d'1 problème sur 40 et le plus souvent identique. Et un modèle qui dépasse un budget de 32 768 tokens sur un cinquième des problèmes de codage ordinaires le fera aussi à un client payant, pas seulement à notre banc d'essai - une réponse tronquée est pire qu'une réponse lente.

## La réserve honnête

40 problèmes ne peuvent pas trancher si un modèle écrit du code 10 % mieux qu'un autre, et nous n'affirmons pas que Qwen3.8-Flash-Next est moins bon. Nous pensons qu'il est probablement meilleur. Ce que nous avons mesuré, c'est que sur ce matériel son avantage est hors d'atteinte : il arrive dix fois plus tard, dans le quart des conversations parallèles, sur un moteur compilé depuis une branche, sans rien d'autre qui tourne sur la machine.

Une autre machine change entièrement cette réponse. 2 de ces machines, ou une avec plus de mémoire, et la table reste en mémoire, le modèle ne partage le matériel avec rien, et la comparaison devient un combat loyal qu'il pourrait fort bien gagner. 3 des modèles que nous avons écartés ce mois-ci l'ont été pour la même raison, ce qui n'est pas vraiment un fait au sujet des modèles.

## Ce qui nous ferait changer d'avis

- **Une table quantifiée.** Personne n'a comprimé les plongements de n-grammes sous les 8 bits, y compris ceux qui ont quantifié tout le reste à 4. À 4 bits, le fichier perd 23,8 Gio et reste en mémoire.
- **Un chemin d'attention linéaire quantifié.** 43 % de ce que le modèle lit par token, ce sont des projections que toutes les versions publiées laissent en pleine largeur. Les diviser par deux double à peu près le plafond.
- **L'architecture dans un moteur publié.** L'architecture n'est disponible que sur une branche et nécessite un correctif de noyau que le projet principal n'a pas intégré pour cette puce. Une version officielle permettrait de remplacer notre assemblage de correctifs par une version standard.
- **Une deuxième machine.** La configuration qu'utilisent tous ceux qui font tourner ce modèle avec succès.

En attendant l'un de ces changements, le point d'accès de codage continue de faire tourner un modèle plus petit, plus ancien et moins bien classé, qui répond en 76 secondes et tient 7 conversations à la fois. Tout ce qui précède est reproductible depuis notre dépôt d'infrastructure : la présélection et son arithmétique, le script de banc d'essai, et la configuration d'évaluation.

---

Autres articles : [Blog CARouter](https://carouter.ai/fr/blog.md). Ce qu'est CARouter et comment l'appeler : [llms.txt](https://carouter.ai/llms.txt).