Comment réduire l'usage des tokens dans Qwen Code

Fait partie du pilier réduire l'usage des tokens des agents IA. Vous utilisez aussi un autre agent ouvert en terminal ? La version opencode couvre les mêmes leviers. Cette page est spécifique à Qwen Code : les réglages qui existent, ce que chacun économise, et ce qu'aucun n'atteint.

Comment réduire l'usage des tokens dans Qwen Code ?

Mesurez le préfixe fixe avec /context detail, réduisez-le avec tools.eager, vérifiez que le token caching est actif, et compactez tôt avec /compress-fast ou un compactionModel moins cher. Puis corrigez le plus gros poste, qu'aucun réglage ne supprime : les fichiers entiers et les sorties de commandes brutes qui entrent dans la conversation.

Qwen Code a de meilleurs outils natifs de maîtrise des coûts que la plupart des agents en terminal. Sa doc consacre une page entière à ce qu'elle appelle le coût du contexte résident, et /stats affiche explicitement les lectures en cache. Le diagnostic est donc facile. La session, elle, ne devient pas bon marché pour autant : chaque réglage ci-dessous agit soit sur le préfixe, soit après coup.

Sources : chaque réglage de cette page a été lu dans la doc de Qwen Code le 14 octobre 2026. Le chiffre de Tokenade vient du benchmark ouvert des optimiseurs de tokens.

Pourquoi Qwen Code consomme-t-il autant de tokens ?

Parce que chaque requête transporte un préfixe fixe plus toute la conversation précédente, et que les deux grossissent plus vite que le travail demandé.

La doc de Qwen Code détaille ce préfixe : le prompt système, le schéma de chaque outil déclaré, vos fichiers de contexte QWEN.md et la liste des skills. Vous le payez à chaque tour, « y compris les tours qui ne font que répondre à une question », comme le dit la page sur le coût du contexte résident.

Par-dessus vient la conversation. Le tour 30 renvoie les tours 1 à 29 : chaque fichier lu, chaque résultat de grep, chaque log de test. Un log de 2 000 lignes lu au tour 5 est refacturé à chaque tour suivant, sauf si le cache l'escompte ou si la compaction le retire.

Il y a donc deux problèmes. Le préfixe est une taxe fixe par requête ; l'historique, une taxe qui se cumule. Qwen Code fournit de bons outils pour le premier et des outils corrects pour le second.

Comment voir où partent les tokens de Qwen Code ?

Lancez /context detail au premier tour d'une session, puis /stats à la fin.

• /context affiche la répartition de la fenêtre de contexte par catégorie. /context detail ajoute une ligne par outil intégré, outil MCP, fichier de contexte et skill. Lisez-le avant votre premier prompt, quand tout ce que vous voyez est du préfixe.
• /stats (alias /usage) ouvre un tableau de bord d'usage. /stats model donne les tokens par modèle avec un coût estimé, /stats tools compte les appels d'outils, /stats daily ou /stats monthly montrent la tendance.
• modelPricing dans settings.json transmet vos vrais tarifs par million à /stats model, pour que l'estimation colle à votre fournisseur.

La doc fait une remarque qui mérite d'être reprise : ne jugez pas le préfixe en part de la fenêtre. La même configuration affiche 6,5 % sur un modèle à 1M de contexte et 37 % sur un modèle à 128k. Elle utilise plutôt le « coût à vide » : les tokens d'entrée d'une session qui pose une question et n'appelle aucun outil.

Quels réglages intégrés réduisent vraiment la facture ?

Cinq, à peu près par ordre de rendement.

1. Le token caching, via une clé API. La page sur le token caching indique qu'il est automatique avec une authentification par clé API (clé Qwen ou fournisseur compatible OpenAI), pas avec OAuth. /stats montre alors combien de tokens d'entrée viennent du cache.
2. Désactivez les fonctions que vous n'utilisez pas. La doc place ce levier en premier : chaque outil déclaré ajoute son schéma à chaque requête, et désactiver une fonction retire aussi ses outils des subagents.
3. tools.eager. Une liste blanche des outils intégrés dont le schéma reste dans la première requête. Les autres deviennent différés et sont atteints via tool_search en cas de besoin. Ce n'est pas une désactivation : pour cela, il faut tools.disabled ou une règle permissions.deny.
4. context.autoCompactThreshold. L'auto-compaction se déclenche par défaut à 85 % de la fenêtre de contexte. Baissez ce seuil et moins d'historique voyage avec chaque requête. Il remplace model.chatCompression.contextPercentageThreshold, désormais ignoré sans avertissement.
5. compactionModel. Le modèle qui rédige le résumé de compaction. Vide, c'est le modèle principal ; la doc note qu'un modèle plus petit peut réduire la latence et le coût de la compression. Réglez-le avec /model --compaction <model-id>.

Trois commandes complètent le tout, et elles ne sont pas interchangeables :

• /compress (alias /summarize) remplace l'historique par un résumé écrit par le modèle. C'est destructif. /summary est la version non destructive : elle écrit .qwen/PROJECT_SUMMARY.md et laisse la conversation intacte.
• /compress-fast compresse sans appel au modèle. Elle retire les anciennes sorties d'outils et les blocs de réflexion, soit exactement ce qui gonfle après une longue séance de debug.
• /clear (aussi /reset, /new) efface tout l'historique. Quand la tâche change, c'est la bonne commande.

Faut-il plafonner les tokens de sortie de Qwen Code ?

Seulement comme garde-fou. La facture se joue rarement en sortie.

Deux réglages existent. QWEN_CODE_MAX_OUTPUT_TOKENS remplace la sortie maximale par défaut de chaque réponse, et samplingParams.max_tokens dans settings.json prend le pas sur lui. Sans aucun des deux, Qwen Code utilise la limite de sortie déclarée du modèle et peut relancer avec une limite relevée (plancher de 64K) quand une réponse est tronquée.

Fixer l'un des deux désactive ce relèvement, selon la référence des réglages. C'est l'arbitrage : un plafond fixe contre des réponses parfois tronquées sur les grosses modifications. La doc le présente surtout pour les backends auto-hébergés qui veulent une réservation plus petite par requête.

Deux garde-fous côté entrée comptent davantage :

• model.sessionTokenLimit bloque l'envoi suivant dès que le nombre de tokens de prompt enregistré dépasse la limite. La valeur par défaut, -1, signifie illimité. C'est un arrêt net pour une session qui s'emballe.
• tools.truncateToolOutputThreshold et tools.truncateToolOutputLines tronquent la sortie de Shell, Grep, Glob, ReadFile et ReadManyFiles au-delà de 25 000 caractères ou 1 000 lignes par défaut.

La troncature reste grossière. Elle coupe selon la taille, pas selon la pertinence : rien ne garantit que l'assertion en échec d'un long log de test soit la partie conservée.

Que laissent intact les réglages de Qwen Code ?

Ce que l'agent lit en cours de session : fichiers entiers, sorties shell brutes, résultats MCP.

Le cache escompte le contexte répété, mais la première fois qu'un fichier de 6 000 tokens entre, vous payez plein tarif plus l'écriture en cache. La compaction agit après coup : le fichier a déjà voyagé à chaque tour avant le seuil. tools.eager réduit les schémas, pas les résultats.

C'est la tranche sur laquelle travaille Tokenade. Sur Qwen Code, tokenade install ajoute des hooks dans ~/.qwen/settings.json (PreToolUse, SessionStart, UserPromptSubmit), si bien que la sortie shell arrive au modèle réduite à ses lignes décisives. Il enveloppe aussi vos serveurs MCP et écrit ses règles dans ~/.qwen/QWEN.md.

Deux réserves, toutes deux dans la matrice de compatibilité. Qwen Code n'exécute les hooks qu'avec hooks.enabled: true dans ~/.qwen/settings.json. Et sous Windows, cmd.exe ne sait pas lire les guillemets du hook : la sortie des commandes est alors compactée par le proxy LLM local, d'où la mention Partial+ dans cette case. Le brief technique complet est sur tokenade.net/agents/qwen-code.md.

Sur le benchmark ouvert des optimiseurs de tokens, il réduit le coût de session de 39 % sur les longues sessions par rapport à l'absence d'outil. Cette campagne a tourné sur Claude Code, pas sur Qwen Code : le mécanisme est le même, la mesure non.

Comment l'appliquer dès aujourd'hui

1. Ouvrez une session neuve et lancez /context detail avant de taper quoi que ce soit. Notez les trois plus grosses lignes.
2. Si vous payez au token, utilisez une authentification par clé API pour que le cache s'applique, et vérifiez la part en cache dans /stats.
3. Désactivez les fonctions inutilisées, puis réglez tools.eager sur les outils intégrés que vous appelez vraiment.
4. Réglez compactionModel sur un modèle moins cher, et envisagez de baisser context.autoCompactThreshold.
5. Lancez /compress-fast après une séance de debug bruyante et /clear quand la tâche change.
6. Puis attaquez les lectures et les logs : installez Tokenade, et vérifiez que hooks.enabled vaut true.

Ce qui tourne mal (anti-patterns)

Lire le pourcentage de la fenêtre. Un préfixe à 6 % d'une fenêtre de 1M coûte exactement ce qu'il coûte à 37 % de 128k. Suivez plutôt le coût à vide.

Taper /summarize en pensant à /summary. L'une réécrit votre historique, l'autre écrit un fichier. L'alias rend l'erreur facile.

Plafonner la sortie pour économiser. Un plafond désactive le relèvement et peut tronquer une grosse modification, que vous payez ensuite pour refaire. La facture est surtout en entrée.

Relever les seuils de troncature pour « tout voir ». Chaque ligne de log en plus est renvoyée à chaque tour suivant. Si vous avez besoin de l'échec, il vous faut un filtre, pas une fenêtre plus grande.

FAQ

Qwen Code met-il les tokens en cache automatiquement ?

Oui, avec une authentification par clé API : clés Qwen et fournisseurs compatibles OpenAI. La doc indique que le cache y est automatique et stocke le contenu souvent réutilisé, comme les instructions système et l'historique. Il ne s'applique pas avec OAuth. Quand il est actif, /stats montre combien de tokens d'entrée ont été servis depuis le cache.

Comment voir l'usage des tokens dans Qwen Code ?

Utilisez /stats (alias /usage) pour le tableau de bord, /stats model pour les tokens par modèle et le coût estimé, /stats daily ou /stats monthly pour la tendance. Pour la composition d'une requête, lancez /context detail au premier tour : il liste chaque schéma d'outil, fichier de contexte et skill du préfixe.

Quelle différence entre /compress et /compress-fast ?

/compress demande à un modèle de résumer la conversation et remplace l'historique par ce résumé. /compress-fast n'appelle aucun modèle : il retire les anciennes sorties d'outils et les blocs de réflexion. La version rapide coûte moins cher et convient aux sessions gonflées par les logs. /summary est encore autre chose : il écrit un fichier de résumé sans toucher à la conversation.

Comment limiter les tokens de sortie de Qwen Code ?

Réglez samplingParams.max_tokens dans settings.json, ou la variable d'environnement QWEN_CODE_MAX_OUTPUT_TOKENS ; le réglage l'emporte sur la variable. L'un comme l'autre désactive le relèvement automatique de la sortie. Pour un arrêt net côté entrée, utilisez model.sessionTokenLimit, qui bloque l'envoi suivant dès que le nombre de tokens de prompt enregistré le dépasse.

Tokenade fonctionne-t-il avec Qwen Code sous Windows ?

Oui. Sous Linux et macOS, les hooks compactent directement la sortie des commandes. Sous Windows, cmd.exe ne sait pas lire les guillemets du hook, la sortie des commandes passe donc par le proxy LLM local de Tokenade, que tokenade install configure via env.OPENAI_BASE_URL dans settings.json. Toutes les autres fonctions sont couvertes sur les trois systèmes.

---

À lire aussi :

• Comment réduire l'usage des tokens des agents IA — le pilier indépendant de l'outil
• Comment réduire l'usage des tokens dans opencode — les mêmes leviers sur opencode
• Comment réduire l'usage des tokens de Grok CLI — l'agent en terminal de xAI
• Réduire les tokens sur les longues sessions — pourquoi l'historique se cumule