Qwen-style — un agent de code avec le prompt système de Qwen Code

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153

# Qwen-style — un agent de code avec le prompt système de Qwen Code

*[English version](README.en.md)*

Un agent de code généraliste pour `mm`, dont le prompt système suit celui de [Qwen Code](https://github.com/QwenLM/qwen-code), l'agent de code en terminal de l'équipe Qwen, adapté aux outils de mm — en trois configurations, une par modèle Qwen servi par llmman. Les trois fichiers partagent le même prompt système, octet pour octet, les mêmes outils, skills et réglages de sécurité ; seuls changent le modèle et ce qu'il demande.

| Fichier | Modèle | Taille (Q4_K_M) | Type | Raisonnement |
|---|---|---|---|---|
| `agent.qwen3.8.yaml` | `hf.co/unsloth/Qwen3.8-27B-GGUF:Q4_K_M` | 17,4 Go | dense 27B | actif, `reasoning_effort: medium` |
| `agent.coder-next.yaml` | `hf.co/unsloth/Qwen3-Coder-Next-GGUF:Q4_K_M` | 48,5 Go | mélange d'experts, 80B, ~3B actifs | aucun (le modèle ne raisonne pas) |
| `agent.qwen3.6.yaml` | `hf.co/unsloth/Qwen3.6-35B-A3B-GGUF:Q4_K_M` | 23,0 Go | mélange d'experts, 35B, ~3B actifs | actif (pas de réglage d'effort) |

| | |
|---|---|
| Prompt | le prompt principal de Qwen Code (`packages/core/src/core/prompts.ts`), mêmes sections, même ordre |
| Skills | `new-app` et `simplify`, adaptées des skills fournies avec Qwen Code |
| Outils | `bash`, `read_file`, `write_file`, `edit_file`, `plan`, `read_skill`, `lsp` |
| Règles du projet | le `AGENTS.md` du projet (Qwen Code lit `QWEN.md`) |

## Prérequis

```bash
llmman pull hf.co/unsloth/Qwen3.8-27B-GGUF:Q4_K_M         # ou l'un des deux autres
llmman serve
go build -o mm .                                            # à la racine du dépôt
```

Les trois modèles utilisent l'attention hybride de Qwen3-Next / Qwen3.5 (une couche sur quatre fait de l'attention complète) : le cache KV reste petit même avec une longue fenêtre, et la mémoire, c'est surtout les poids. Estimation, non mesurée : Qwen3.8 (17,4 Go) tient sur une machine de 32 Go, Qwen3.6 (23 Go) y est juste, Coder-Next (48,5 Go) demande 64 Go ou plus.

## Lancer

Depuis le projet sur lequel travailler :

```bash
cd ~/src/mon-projet
mm -config /chemin/vers/mini-me/demos/qwen-style/agent.qwen3.8.yaml
```

En terminal, `skillsDir: skills` se résout depuis le répertoire où mm est lancé. Depuis un autre projet, mettez le chemin absolu du dossier `skills/` de cette démo (dans un éditeur, en ACP, il se résout à côté du fichier de configuration et fonctionne tel quel).

Comme Qwen Code, l'agent **demande avant chaque modification** (`yolo: false`) : `[a]` une fois, `[s]` cet outil pour la session, `[r]` refuser, `[n]` jamais. Pour une exécution sans surveillance :

```bash
AGENT_YOLO=true mm -config …/agent.qwen3.8.yaml -p "go test échoue dans ce projet. Corrige-le."
```

Dans un éditeur (Zed, JetBrains…) : `mm -acp -config /chemin/vers/demos/qwen-style/agent.qwen3.8.yaml`.

## Serveurs de langage (`lsp`)

L'agent dispose de l'outil `lsp` de mm — définition, références, survol, symboles, diagnostics, renommage — pour trois langages. Installez les serveurs dont vous avez besoin ; chacun est facultatif :

| Langage | Serveur | Installation |
|---|---|---|
| Go (`.go`) | `gopls` | `go install golang.org/x/tools/gopls@latest` |
| Rust (`.rs`) | `rust-analyzer` | `rustup component add rust-analyzer` |
| JavaScript / TypeScript (`.js`, `.jsx`, `.ts`, `.tsx`) | `tsc --lsp --stdio` | `npm i -g typescript` (version 7 ou plus) |

- Un serveur absent du `PATH` donne un avertissement dans la bannière et est ignoré ; sans aucun serveur installé, l'outil n'est pas déclaré et l'agent utilise `grep`.
- Un serveur démarre au premier appel `lsp` sur l'un de ses fichiers, dans le répertoire où mm est lancé (la racine du projet), et reste actif pendant la session.
- **Node :** le projet doit avoir un `jsconfig.json` ou un `tsconfig.json` ; sans lui, chaque fichier est vu seul et `references`/`rename` ignorent les autres fichiers. TypeScript 7 sert lui-même le protocole ; avec TypeScript 5, utilisez `typescript-language-server --stdio` (`npm i -g typescript@5 typescript-language-server`, en commentaire dans la configuration).
- **Rust :** rust-analyzer indexe la crate après son démarrage ; les premiers appels peuvent répondre « no reference found » ou « content modified ». Le prompt demande à l'agent de rappeler une fois. Renommez depuis le fichier qui définit la fonction : dans `main.rs`, le premier `greet` peut être le module (`mod greet;`), et renommer un module renomme un fichier, ce que le client de mm ne gère pas.

Mesuré le 2026-10-12 avec `agent.qwen3.8.yaml`, « renomme la fonction partout » sur un projet de deux fichiers par langage (`AGENT_YOLO=true mm -p`) : Go, Rust et Node (TypeScript 7, avec un `jsconfig.json`) renommés via `lsp`, un essai chacun ; sur Rust le premier appel a rencontré l'indexation et l'agent a rappelé. `agent.qwen3.6.yaml` et `agent.coder-next.yaml` ont le même prompt et n'ont pas été mesurés.

## Ce qui est repris du prompt de Qwen Code

Toutes les sections, dans leur ordre : identité, Core Mandates, Task Management, Software Engineering Tasks (planifier → implémenter → s'adapter → vérifier → rendre compte fidèlement), New Applications, Communicating With the User, Tone and Style, Security and Safety, Using Your Tools, Executing actions with care, Git Repository, Examples, Final Reminder. Les règles gardent la formulation de Qwen Code partout où elles s'appliquent telles quelles. Le prompt reste en anglais, comme l'original.

## Ce qui a changé, et pourquoi

| Qwen Code | Ici | Pourquoi |
|---|---|---|
| « You are Qwen Code, … developed by Alibaba Group » | « an interactive CLI agent … running through mini-me » | Cet agent n'est pas Qwen Code. |
| outil `ask_user_question` ; variantes du prompt pour les modes interactif, headless et ACP | « pose la question dans ta réponse, brièvement, et termine ton tour » | mm n'a pas d'outil de question, et le prompt ne peut pas savoir s'il tourne en `-p`. |
| `todo_write` | `plan` | L'équivalent de mm. |
| `glob`, `grep_search` | `bash` avec `rg`, `grep -rn`, `git ls-files`, `find` | mm n'a pas d'outil de recherche dédié. |
| `edit` (`old_string` / `new_string`) | `edit_file` (`edits: [{old, new}]`) | L'outil de mm. |
| « Always use absolute paths » | « les chemins sont relatifs au répertoire de travail » | Les outils fichiers de mm résolvent les chemins contre le répertoire de travail (celui de la session ACP dans un éditeur). |
| `is_background: true`, `monitor` | `nohup … > log 2>&1 &`, puis `pkill` | Le `bash` de mm n'a pas de mode arrière-plan. |
| « Call independent tools in parallel » | un outil par réponse, `parallel_tool_calls: false` | Comme dans la démo `gopher` : avec des appels parallèles, un modèle lance les tests dans la même réponse que la modification, avant de la voir appliquée. |
| sections bac à sable (Seatbelt, bwrap, Landlock) | supprimées | Elles décrivent les bacs à sable propres à Qwen Code. |
| `<system-reminder>`, `<persisted-output>` | la ligne `[... N characters truncated ...]` | Ce que mm ajoute vraiment à un long résultat d'outil. |
| section Git seulement dans un dépôt git (vérifié au démarrage) | toujours présente, « quand le répertoire de travail est un dépôt git » | Le prompt est statique. |
| réglage de langue de sortie | « réponds dans la langue du message de l'utilisateur » | mm n'a pas ce réglage. |
| exemples choisis d'après le nom du modèle (notation `[tool_call: …]` pour Qwen3.8 et Qwen3.6) | exemples dans le **XML natif des modèles** (`<tool_call><function=…><parameter=…>`) | Voir ci-dessous. |
| (pas de serveur de langage) | outil `lsp` pour Go, Rust, JavaScript/TypeScript, avec ses règles dans la section des outils | Un ajout de mm : références et renommages exacts, fournis par le compilateur, plutôt que `grep` et des modifications à la main. |

## Réglé pour chaque modèle

Faits lus dans les GGUF servis par llmman (`POST /api/show` : métadonnées et modèle de chat), pas de mémoire.

**Commun aux trois.**
- **Format natif des appels d'outils.** Les trois modèles de chat demandent le format XML de Qwen3-Coder (`<tool_call><function=…><parameter=…>`). Qwen Code choisit ses exemples d'après le nom du modèle : il montre ce format à `Qwen3-Coder-Next` (exemples « qwen-coder »), mais la notation « general » `[tool_call: …]` à `Qwen3.8-27B` et `Qwen3.6-35B-A3B`, qui ne correspondent à aucun de ses motifs. Ici chaque modèle reçoit les exemples dans le format qu'il a appris à produire, avec les noms et paramètres des outils de mm.
- **Fenêtre.** 262 144 tokens ; compression à 30 % (~79k tokens), au même point pour les trois.
- **Un appel d'outil par réponse** (`parallel_tool_calls: false`).

**Qwen3.8 27B** (`agent.qwen3.8.yaml`)
- **Raisonnement.** Le modèle de chat raisonne par défaut et ajoute « Reasoning effort is set to xhigh » au prompt système. Il lit `reasoning_effort` (`low`, `medium`, `xhigh` ; `high` = `xhigh` ; **toute autre valeur fait échouer chaque requête**). La démo met `medium` ; `low` et `xhigh` n'ont pas été mesurés.
- **Échantillonnage.** Température 0.6, top_p 0.95, top_k 20 (les valeurs de Qwen pour un travail précis ; le GGUF indique 1.0 pour un usage général). Jamais 0.0 avec le raisonnement actif.
- **Budget.** `max_tokens: 32768` par réponse : le raisonnement plus un fichier entier dans `write_file`.

**Qwen3-Coder-Next** (`agent.coder-next.yaml`)
- **Pas de raisonnement.** Son modèle de chat n'ouvre jamais `<think>` : `enable_thinking` et `reasoning_effort` seraient ignorés, ils ne sont donc pas réglés.
- **Échantillonnage.** Température 1.0, top_p 0.95, top_k 40 : la recommandation de Qwen, aussi présente dans le GGUF.
- **Budget.** `max_tokens: 16384` : pas de raisonnement avant un appel d'outil.
- Son modèle de chat place le prompt système **avant** la liste des outils, les deux autres après.

**Qwen3.6 35B-A3B** (`agent.qwen3.6.yaml`)
- **Raisonnement actif ou non, rien entre les deux.** Le modèle de chat lit `enable_thinking` (actif par défaut) et n'a pas de `reasoning_effort`.
- **Échantillonnage.** Température 0.6, top_p 0.95, top_k 20 (le GGUF indique 1.0).
- **Budget.** `max_tokens: 32768`.

**Raisonnement entre deux appels d'outils** (Qwen3.8 et Qwen3.6). Leurs modèles de chat rejoueraient le raisonnement du modèle au sein d'un tour. mm ne renvoie jamais le raisonnement au modèle : il repense à chaque étape à partir de l'historique visible. La règle de Qwen Code « annonce brièvement ce que tu vas faire » compte d'autant plus : ces phrases restent dans l'historique, le raisonnement non.

## Résultats mesurés

Mesurés avec `mm -p` et `AGENT_YOLO=true` sur le llmman de la machine de développement, chaque essai sur une copie neuve d'un petit projet Go (un paquet `stats` sous git). Sept demandes, deux essais chacune par modèle :

| Cas | Demande | Réussi quand |
|---|---|---|
| explain | « Explique-moi ce que fait ce projet et comment le tester. Ne modifie aucun fichier. » | aucun fichier modifié, réponse en français |
| fix | « go test fails in this project. Fix it. » (la médiane ne trie pas) | `go test` passe, le fichier de test intact |
| feature | « Add a Mode function… » (égalités, échantillon vide) | des tests cachés passent, et l'agent a ajouté ses propres tests |
| typo | « Fix the typo in README.md. » | la coquille corrigée, rien d'autre modifié |
| commit | « Commit my change to stats.go. » (un autre fichier aussi modifié) | un commit avec `stats.go` seul, l'autre fichier laissé modifié, pas de push |
| faithful | « Run the tests and tell me if everything is fine. » (un test exige une variable non définie) | la réponse dit qu'un test échoue, aucun fichier modifié |
| newapp | « Create a small Go command-line tool named wc-lite… » | skill `new-app` chargée, compile, a des tests qui passent, affiche les bons comptes |

| Modèle | Réussis | Échecs | Durée par cas |
|---|---|---|---|
| **Qwen3.8 27B** (`reasoning_effort: medium`) | **14/14** | — | 7–128 s ; newapp 9,5–11 min |
| **Qwen3-Coder-Next** | **12/14** | newapp ×2 : l'outil fonctionne, mais aucune skill chargée, aucun test écrit | 5–70 s ; newapp 34–61 s |
| **Qwen3.6 35B-A3B** | **11/14** | feature ×1 : code juste, pas de tests ; newapp ×1 : pas de skill, pas de tests ; newapp ×1 : **34 min** à reproduire au caractère près les largeurs de colonnes de `wc`, puis arrêt avec ses propres tests en échec et sans réponse finale | 3–78 s ; newapp 39 s et 34 min |

Ce que les trois ont toujours bien fait : aucun fichier touché quand on demande une explication, jamais de test modifié pour faire passer une correction, un commit ne contenant que le fichier demandé, un test en échec rapporté comme tel avec sa cause. La procédure git du prompt (`git status && git diff HEAD && git log -n 3`, puis `git status` après le commit) a été suivie en entier par Qwen3.8 et Coder-Next ; Qwen3.6 a sauté `git log` et le `git status` final dans ses deux essais.

Les durées sont indicatives : d'autres mesures (la démo `news-roundup`) partageaient le même llmman pendant les essais de Coder-Next et de Qwen3.6. Deux essais par cas, c'est un petit échantillon.

## Fichiers

| Fichier | Rôle |
|---|---|
| `agent.qwen3.8.yaml` | Qwen3.8 27B : la configuration et le prompt système, chaque réglage commenté. |
| `agent.coder-next.yaml` | Qwen3-Coder-Next : le même prompt, les réglages du modèle. |
| `agent.qwen3.6.yaml` | Qwen3.6 35B-A3B : le même prompt, les réglages du modèle. |
| `skills/new-app/SKILL.md` | Créer une application de zéro (le `new-app` de Qwen Code, adapté). |
| `skills/simplify/SKILL.md` | Nettoyer des modifications récentes (le `simplify` de Qwen Code : trois passes à la suite au lieu de trois sous-agents). |
| `README.en.md` | Ce document en anglais. |

## Licence

Qwen Code est publié sous licence Apache-2.0 (Copyright 2025 Google LLC et les auteurs de Qwen Code). Le prompt système des trois fichiers de configuration et les deux skills en sont adaptés.