ADHD pour Coding Agents : un moteur de raisonnement parallèle façon Tree-of-Thought

Un appel CLI vers un LLM se fige parfois pendant 90 secondes. Comment concevoir la logique de retry et de timeout ? La réponse scolaire arrive vite : backoff exponentiel avec jitter, timeout absolu, puis un retry automatique. Ce n’est pas faux. Mais la vraie question est peut-être ailleurs : est-ce vraiment le réseau qui est lent, ou le mauvais modèle qui a été choisi ? Plus l’utilisateur attend, plus le bouton ne devrait-il pas devenir urgent, avec une option pour relancer en un clic sur un modèle plus rapide ?

ADHD est conçu pour ce type de problème. Ce n’est pas un prompt qui dit à l’Agent : “réfléchis encore”. C’est une structure de raisonnement parallèle pour les agents de code IA. Plusieurs branches isolées divergent avec des frames cognitifs différents. Ensuite, un critic séparé note les idées, les regroupe, coupe les pièges et approfondit les survivants. Ici, on se concentre sur le mécanisme, les limites et les moments où ce skill vaut le coût.

Ce qu’est ADHD (pas un truc de prompt)

Le positionnement d’ADHD est clair : il tente de réduire la convergence prématurée dans le raisonnement autorégressif, pas d’ajouter quelques mots d’encouragement au prompt.

Un modèle autorégressif génère un token après l’autre. Dès que les premiers pas choisissent une direction, le reste de la réponse se construit autour d’elle. C’est efficace, mais les tâches d’ingénierie ouvertes révèlent le défaut : la première réponse plausible devient l’ancre. Le modèle glisse vers le chemin le plus courant, le plus scolaire. Cette réponse est souvent suffisamment correcte, mais elle rate souvent l’option moins évidente qui aurait plus de valeur.

Des prompts classiques peuvent demander au modèle de “comparer plusieurs options”, de “penser sous différents angles” ou d‘“éviter de conclure trop vite”. Le problème, c’est que ces branches partagent toujours le même contexte. Le modèle génère et évalue dans le même espace. Dès qu’une direction apparaît tôt, les branches suivantes ont du mal à s’en détacher.

ADHD prend une voie plus dure. La phase de divergence devient N appels Agent SDK totalement isolés. Chaque branche voit seulement le problème d’origine, un frame cognitif et un system prompt qui interdit l’évaluation. Les branches ne partagent aucun contexte. Une phase Focus utilise ensuite un appel critic séparé pour noter, regrouper, élaguer et approfondir les résultats.

En une phrase : CoT fait réfléchir un cerveau plus lentement, Tree-of-Thought fait chercher un cerveau plus largement, et ADHD fait penser plusieurs cerveaux différemment en parallèle avant de laisser un critic choisir.

Mécanisme en deux phases : un mur dur entre Diverge et Focus

ADHD repose sur deux phases : Phase 1 Diverge et Phase 2 Focus. Un mur dur les sépare. La divergence interdit l’évaluation ; seule la phase Focus a le droit de converger.

KiloClaw - OpenClaw managé pour l’entreprise : orchestration d’agents IA et routage intelligent

Commencer →Pub

Phase 1 Diverge : N branches isolées en parallèle

La première phase choisit N frames cognitifs, avec N=5 par défaut, puis lance N requêtes Agent SDK isolées en parallèle. Chaque branche ne reçoit que trois entrées :

1. Le problème d’origine.
2. Le prompt de point de vue d’un frame, par exemple relire le problème par la latence, le layout mémoire, la régulation, l’astreinte ou l’inversion.
3. Un system prompt qui interdit l’évaluation, le classement et les formulations prudentes.

Les branches ne se voient pas. La branche regulatory audit ne peut pas lire ce que la branche speedrunner a écrit. La branche hardware engineer n’est pas ancrée par la branche 10-year-old child. Chaque branche est une session stateless indépendante : l’ancrage n’est pas supprimé par la discipline du modèle, il est retiré par la structure.

La concurrence est contrôlée par un semaphore, avec concurrency=4 par défaut. Le coût en tokens croît linéairement avec le nombre de branches : O(N×chaque branche), pas N², car les branches suivantes ne relisent pas le contenu complet des branches précédentes.

Phase 2 Focus : un appel critic séparé

La deuxième phase bascule vers un appel critic séparé. Il fait trois choses :

1. score : noter chaque branche sur novelty, viability et fit de 0 à 10, avec des raisons mécanistes pour les pièges.
2. cluster : grouper les idées selon leur angle sous-jacent, pas selon des mots-clés de surface.
3. deepen top-K : approfondir par défaut K=3 idées survivantes avec des croquis, des risques porteurs, une première action et 3 à 5 sous-idées.

Le choix important est la séparation mécanique entre generator et critic. La phase generator ne doit pas évaluer. La phase critic doit évaluer. Ce ne sont pas deux promesses dans le même chat, mais deux appels API distincts avec des system prompts différents et une posture opposée.

La forme d’appel d’une branche isolée ressemble à ceci :

const branches = await Promise.all(
  frames.map((frame) =>
    withSemaphore(concurrency, () =>
      callLLM({
        systemPrompt: `${frame.vantage}\n\nFORBIDDEN: evaluation, ranking, hedging. JSON array out.`,
        userPrompt: `${problem}\n\n${context ?? ""}`,
      }),
    ),
  ),
);

Revenons à l’exemple retry/timeout. Une réponse baseline tend à proposer un hybride standard : 15 secondes pour le premier token, 30 secondes entre tokens, une limite dure à 90 secondes et un retry automatique. La valeur d’ADHD n’est pas de rendre cette réponse plus longue. Il peut faire émerger une option comme “rendre le bouton plus urgent à mesure que l’attente augmente, puis permettre d’annuler et de relancer sur un modèle plus rapide”, tout en signalant avant implémentation des idées amusantes mais dangereuses comme “streamer les tokens à l’envers” ou “facturer selon la patience”.

Comparaison structurelle avec CoT et ToT

Trois différences porteuses

D’abord, ADHD est une isolation, pas une recherche. Les branches ToT se déploient toujours dans un arbre où les premiers nœuds influencent les suivants. Les branches ADHD ne se voient pas pendant la divergence : l’ancrage est donc retiré par construction.

Ensuite, ADHD utilise des frames, pas des variantes de prochaine étape. ToT élargit souvent la question “quel est le prochain mouvement ?”. ADHD repose toute la question depuis une autre position cognitive. Il ne change pas juste un paramètre ; il reconsidère la tâche par la latence, les contraintes physiques, la responsabilité réglementaire ou la pression d’une astreinte à 3 h du matin.

Enfin, la séparation generator-critic est mécanique, pas déclarative. Dire “n’évalue pas encore” dans un seul contexte n’empêche pas le modèle de comparer les idées pendant qu’il les génère. ADHD sépare ce travail par des appels, des system prompts et des postures distincts.

Une clarification compte : un frame n’est pas une persona. Une persona dit : “vous êtes telle personne”. Un frame dit : “reposez ce problème avec ces contraintes et ce vocabulaire”. Le premier change l’étiquette d’identité. Le second change le cadre du problème.

Les 15 frames cognitifs et la personnalisation

ADHD fournit 15 frames cognitifs qui tordent le même problème dans différentes directions. codeMode privilégie par défaut les perspectives code et design, et chaque lancement garde un wild slot pour éviter une divergence trop propre.

Exemples de frames intégrés

Règles de sélection

• Le même problème avec le même seed choisit le même ensemble de frames, ce qui rend les exécutions reproductibles.
• codeMode privilégie par défaut les frames code/design, donc une tâche d’ingénierie n’est pas confiée uniquement à des métaphores hors sujet.
• Chaque lancement garde un wild slot, ce qui donne au système une chance de sortir d’un ensemble de frames trop sage.

Frames personnalisés

Un frame personnalisé n’a pas besoin d’être long. Il doit vraiment changer la manière de voir le problème. Un bon frame respecte au moins deux de ces trois règles :

Alibaba Cloud - Choix n°1 des développeurs, 15 % de réduction exclusive sur Lighthouse

Obtenir -15 % →Pub

1. Il a un vocabulaire distinctif, pas seulement “penser sous plusieurs angles”.
2. Il a une posture distinctive : adversariale, constructive, naïve ou très contrainte.
3. Il produit une distorsion reproductible, qui change régulièrement la direction du raisonnement.

Par exemple, pour un produit par abonnement :

name: subscription_retention
vocabulary: ["subscription", "retention", "churn", "renewal", "lifecycle"]
stance: "Think in terms of subscription churn and lifetime value, not one-time transactions"
distortion: "Assume users will churn; design mechanisms that reduce churn"

Cela ne se contente pas d’étiqueter le modèle comme “responsable growth”. Le problème est poussé dans les contraintes de retention, churn et lifetime value.

Quand l’utiliser, et quand l’éviter

ADHD est un outil de point de décision, pas un outil à chaque frappe. Un test simple fonctionne bien : si un développeur junior peut le trouver sur Google, la baseline gagne. Si un développeur senior s’arrêterait pour dire “je dois le regarder sous un autre angle”, ADHD entre dans le périmètre.

Bons cas d’usage

Mauvais cas d’usage

Installation et déclenchement

Examinez le skill tiers avant de l’installer. Lisez au minimum son SKILL.md : que demande-t-il à l’Agent, peut-il lancer des commandes externes, peut-il toucher des répertoires sensibles ? La checklist du guide de revue de sécurité des skills OpenClaw donne un bon point de départ.

Installation générale

La commande d’installation générale est :

npx skills add UditAkhourii/adhd

Elle détecte automatiquement environ 50 Agents, dont Claude Code, Cursor, Antigravity, Codex, Cline, Gemini CLI et Windsurf, puis installe le fichier skill correspondant.

Installation spécifique à Codex

Si la commande générale n’enregistre pas le skill dans Codex, forcez la cible :

npx skills add UditAkhourii/adhd -a codex -g

Vous pouvez aussi l’installer manuellement :

curl -o ~/.codex/skills/adhd/SKILL.md https://raw.githubusercontent.com/UditAkhourii/adhd/main/SKILL.md

Après une installation manuelle, redémarrez Codex pour recharger le répertoire des skills.

Déclenchement

Déclenchez-le avec :

/adhd "problème"

Par exemple :

Railway - Plateforme de déploiement moderne, sans opérations complexes, en ligne en quelques minutes

Commencer →Pub

/adhd "Un appel CLI vers un LLM se fige parfois pendant 90s. Comment concevoir retry/timeout/UX ?"

Ne le branchez pas sur chaque complétion. Le meilleur usage consiste à le déclencher explicitement sur l’architecture, le design d’interface, le naming ou le débogage flou.

Coût et valeur

Données de coût

Positionnement de valeur

Le projet le formule ainsi : dépenser de l’ordre de 0,30 USD pour soutenir une décision d’architecture valant 50 000 USD. Ce n’est pas un argument pour lancer ADHD sur chaque petite question. C’est un rappel : une mauvaise décision d’ingénierie ouverte peut coûter bien plus cher qu’un seul raisonnement multi-branches.

Dans les vrais projets, le coût de contexte compte aussi. Dans Claude Code ou une session Agent similaire, chaque branche peut recharger le contexte projet de base, les consignes d’outils et les règles du dépôt. Le coût algorithmique pur est O(N×chaque branche), mais la facture pratique ressemble davantage à N×(contexte de base + travail de branche). C’est donc un outil pour “devons-nous concevoir ainsi ?”, pas pour “quelle est la prochaine ligne de code ?”.

Lire les résultats d’eval

Le projet ADHD publie une auto-évaluation : six tâches d’ingénierie ouvertes, même modèle, jugement LLM indépendant, ordre A/B randomisé. Gardez ce périmètre visible. Ce n’est ni un benchmark académique tiers, ni une évaluation humaine.

Comparaison sur cinq dimensions

Prudence sur le cadre d’évaluation

Ces chiffres sont utiles pour comprendre une direction, pas pour faire une affirmation de benchmark autoritaire. Ils ne prouvent pas qu’ADHD bat toutes les autres stratégies de raisonnement. Ils soutiennent une lecture plus étroite : sur des prompts d’ingénierie ouverts, divergence isolée plus critic séparé peuvent modifier visiblement l’étendue, la nouveauté et la détection des pièges.

Évitez donc de l’écrire comme “performance de benchmark leader du secteur”. La formulation plus sûre est : dans l’auto-évaluation du projet sur six tâches d’ingénierie ouvertes, ADHD en a gagné cinq, avec le plus grand écart sur trap detection. Si la frontière factuelle reste claire, le lecteur peut juger lui-même le poids de ces chiffres.

Conclusion

ADHD est intéressant non pas parce qu’il rend les réponses plus longues, mais parce qu’il transforme “penser différemment” en structure : les branches sont isolées, les frames reposent le problème, et un critic séparé élague les résultats. Cette structure correspond bien à une faiblesse fréquente des Coding Agents sur les tâches d’ingénierie ouvertes : converger trop tôt vers la première réponse qui semble correcte.

Utilisez-le sur les points de décision, pas dans les boucles quotidiennes à chaque frappe. Architecture, interfaces, naming, migrations et débogage flou valent 30 à 90 secondes de plus. Recherche de faits, bugs dont la cause est connue et boilerplate d’une ligne conviennent mieux à un Agent baseline.

Si vous organisez votre toolchain d’AI coding, lisez le panorama 2026 des outils de programmation IA pour situer ce type de skill. Pour comprendre comment organiser des chaînes de raisonnement plus longues, le guide d’architecture DeepAgents est aussi utile.