Agent IA spécialisé contre couteau suisse universel : comment nous avons réduit la latence de réponse de 17 à 7,7 secondes

• Réduction de la latence de réponse : la médiane est passée de ~17 s (13,3–20,6 s) à 7,7 s (7,25–7,93 s)
• Compression du préfixe d'entrée : de 15 266 à 1 424 tokens par requête (économie d'un facteur 10,7 sans changer la logique métier)
• Volume du noyau déterministe : 766 lignes de plugin Python de gamification au-dessus de SQLite et 342 lignes de vérificateur de notation
• Plafond pratique du fichier de personnalité : environ 20 000 octets pour `SOUL.md` sans perte d'attention du modèle sur le milieu de l'instruction

La première tentation lors de la construction d'un agent IA, c'est de lui donner accès à tout d'un coup : terminal, navigateur, recherche web, fichiers et serveurs MCP. La prise de conscience est venue avec un tuteur d'échecs pour enfants, déployé via un endpoint local `/v1/chat/completions`. L'enfant déplaçait une pièce sur l'échiquier, et le commentaire de l'entraîneur arrivait 17 secondes plus tard — le temps que le jeune joueur ait déjà fait deux coups supplémentaires.

L'analyse a montré que sur 15 266 tokens de préfixe d'entrée, près de 14 000 étaient occupés par des schémas JSON d'outils jamais appelés une seule fois pendant la partie d'échecs, plus une collecte automatique d'informations sur l'OS au démarrage. Pire encore, l'agent disposant de `execute_code` se mettait, à la moindre difficulté, à écrire et exécuter des scripts dans le bac à sable, transformant un simple coup en vingt appels API.

Comment trois lignes de configuration compressent le prompt d'un

facteur 10,7 et éliminent la latence ?

Pour transformer ce généraliste contemplatif en service rapide, il n'a pas fallu réécrire le code du plugin. Nous avons verrouillé trois paramètres dans la configuration du runtime :

1. Nous avons limité la plateforme `api_server` à un seul ensemble d'outils spécialisé (`[chess]`), en retirant les trousses à outils fichiers et shell. 2. Nous avons désactivé `environment_probe`, qui à chaque démarrage interrogeait l'hôte et insérait un instantané de l'environnement dans le prompt système. 3. Nous avons fixé `reasoning_effort: none` — puisque les faits tactiques sont déjà calculés par le moteur Stockfish, le modèle n'a pas besoin de construire une chaîne de raisonnement avant de répondre, sa tâche étant simplement d'énoncer avec vivacité le verdict déjà prêt.

Sur les mesures de contrôle avec cache chaud, le temps de réponse est passé de `13,3 / 17,3 / 20,6 s` à `7,25 / 7,74 / 7,93 s` (médiane 7,7 s), tandis que la consommation de tokens d'entrée chutait d'un facteur 10,7 — de 15 266 à 1 424. La réduction du jeu d'outils économise des tokens et protège le système contre toute initiative intempestive dans le terminal, tandis que la désactivation de l'étape de raisonnement superflue apporte le principal gain en secondes. Détail important : les profils d'outils pour la messagerie et pour le planificateur (`cron`) sont définis séparément — si l'on oublie d'inscrire le plugin dans la section `cron`, l'envoi matinal se mettra silencieusement à chercher des données en lisant des fichiers.

Comment diviser la personnalité en deux couches et déléguer le calcul

des séries à SQLite ?

La personnalité d'un agent spécialisé se conçoit sur deux niveaux : un court bloc déclencheur dans `config.yaml` (10–15 lignes) définit le routage (`tutor_state` en début de dialogue, `tutor_record_lesson` après un exercice), tandis que le règlement de ton et de pédagogie vit dans `SOUL.md`. Le plafond opérationnel de ce fichier est d'environ 20 000 octets (6,7–19,9 Ko pour mes bots) : au-delà, le modèle perd les règles situées au milieu.

Le modèle de langage excelle à jouer les émotions, mais calcule mal les dates, les points d'expérience et les notes selon des barèmes. Dans le tuteur de langues, tous les calculs de gamification (10 niveaux de 0 à 8000 XP, paliers de séries de 3 à 365 jours, 15 badges et des cristaux) sont délégués à un plugin Python de 766 lignes au-dessus de SQLite :

```python if last_date == today: streak = max(1, prev_streak) elif last_date == yesterday or not last_date: streak = (prev_streak + 1) if last_date == yesterday else 1 else: gap_days = (parse_date(today) - parse_date(last_date)).days if freezes > 0 and gap_days == 2: freezes -= 1 streak = prev_streak + 1 events.append({"type": "freeze_used", "msg": "Заморозка спасла серию дней!"}) else: if prev_streak > 1: events.append({"type": "streak_reset", "old": prev_streak}) streak = 1 ```

L'outil retourne un tableau `events`, et le champ `description` du schéma JSON de la fonction elle-même contient une directive : féliciter avec émotion l'élève pour chaque événement de `events` et ne rien inventer de son propre chef sur le solde. De même, dans le simulateur de négociations d'achat, un barème de 4 modules sur une échelle de 40 points vérifie par le code les marqueurs sémantiques (risques, vérification des faits, négociation) afin que le participant ne puisse pas « convaincre » le réseau de neurones de relever sa note.

Pourquoi la progression se réinitialisait-elle silencieusement après

un redémarrage, et comment réparer le framework ?

Dans les premières versions, le moteur transmettait au gestionnaire d'outils un paramètre `task_id` égal à l'ID de la session en cours, et je l'utilisais comme clé primaire de l'élève. En appuyant sur `/new` ou au redémarrage du conteneur, un nouveau `task_id` était généré, et l'utilisateur se retrouvait devant une page blanche au lieu de 30 jours d'apprentissage. Le problème a été résolu par un résolveur de clé à deux niveaux, qui extrait par expression régulière l'ID permanent du compte depuis `telegram:dm:<user_id>` ou le vérifie dans `sessions.json`, garantissant une clé stable `tg:<id>`.

Pour éviter de reconstruire une image d'un gigaoctet à chaque nouvelle bibliothèque, le déploiement installe les paquets via `pip install --target` dans le volume `data/pylibs`, applique un `chown -R` pour l'utilisateur non-root et nettoie les `__pycache__`. Et là où le transport de base manquait du clavier inférieur ou avalait `/start`, des correctifs auto-réparateurs issus de `bootstrap.sh` vérifient au démarrage des ancres dans le code de l'adaptateur, insèrent le bloc manquant et vérifient le fichier via `py_compile`.

Le principe « le plugin déterministe calcule, le modèle étroit joue le rôle » est intégré au cœur de [Nomad AI](https://nomadnet.ai) et de l'environnement cloud [agent.nomadnet.ai](https://agent.nomadnet.ai). Des laboratoires pour construire ce type d'agents sont disponibles sur [Hamidun Academy](https://academy.hamidun.com) (72 heures d'essai gratuit), et les plugins prêts à l'emploi ainsi que plus de 370 compétences sont décortiqués dans le [Vibe Club](https://hamidun.com/club).