Masterclass sur l'agent Hermes

Tout ce qu'il faut pour comprendre et personnaliser Hermes Agent. Compétences auto-évolutives, mémoire à trois niveaux, optimisation GEPA, et passer de 1 à 10 agents qui travaillent pour vous 24h/24 et 24 et 7j 7j 7.

Hermes Agent a dépassé les 90 000 étoiles GitHub en deux mois. Les développeurs construisent discrètement des agents IA personnels qui apprennent leur flux de travail, se souviennent de leur contexte et fonctionnent 24h/24 et 7j/7.

Tous les agents IA que vous avez utilisés ont le même problème : ils oublient tout dès que votre session se termine.

Vos préférences de codage, les conventions de projet que vous lui avez corrigées trois fois, le correctif qu'il a mis 10 minutes à trouver hier. Tout disparaît. Session suivante, vous repartez de zéro.

Hermes Agent de Nous Research adopte une approche fondamentalement différente. Il embarque une boucle d'apprentissage qui :

Se souvotre session,
Écrit ses propres compétences réutilisables,
Les élaguer en arrière-plan,
Et les valide hors ligne via un moteur d'évolution appelé GEPA.

Aucun autre agent open source ne combine les trois. Même pas OpenClaw non plus.

Ce guide explique comment fonctionne cette boucle d'apprentissage, ce que fait chaque couche de mémoire, et comment tout configurer à partir de zéro.

À la fin, vous aurez trois agents totalement isolés sur votre machine : un programmeur (qui utilise votre Claude Code), un chercheur approfondi et un designer, chacun avec sa propre personnalité, sa mémoire, ses compétences et son bot Telegram.

Regardez ceci :

L'ensemble prend quelques minutes et tout est reproductible sur votre propre matériel.

Remarque : Toutes les illustrations de ce guide ont été conçues par Pixel, l'un des agents Hermes que vous apprendrez à construire à construire à la fin. Gardez un œil sur elles en lisant.

Commençons !

Comment lire ce guide

Deux parties : la théorie d'abord, la pratique ensuite.

Vous manquez de temps ? Passez directement à la section « Mise en route ». Les commandes fonctionnent seules.

Mais la théorie en vaut la peine. Comprendre comment les compétences évoluent, comment la mémoire se compose, et quand GEPA est utile, c'est la différence entre utiliser Hermes comme un chatbot avec des notes et l'utiliser comme quelque chose qui s'améliore avec le temps.

Ce qui vous attend :

Ce qu'est réellement Hermes Agent. Le pitch, plus une comparaison avec OpenClaw.
Comment c'est construit. L'architecture en un schéma.
Avant la mémoire : Qui est l'agent ? SOUL.md, la couche d'identité.
Le système de mémoire. Trois niveaux, trois vitesses.
Compétences auto-évolutives. Des playbooks créés par l'agent plus le Curateur.
GEPA. Optimisation hors ligne des compétences.
Mise en route. Installation, Telegram, premier agent.
Exécution de plusieurs agents. Profils, trois personnalités, résumés programmés.
Personnalisation des agents selon vos besoins.

Ce qu'est Hermes et ce qui le rend architecturalement différent

Le pitch en une ligne : un agent qui s'améliore plus vous l'utilisez.

Ce qui rend cela possible, c'est que trois capacités habituellement séparées se trouvent dans un seul cadre : l'apprentissage de compétences à l'exécution, la mémoire persistante multicouche, et un pipeline d'optimisation optionnel. Aucun autre agent open source ne propose les trois.

La comparaison la plus proche dans l'écosystème open source est OpenClaw. Les deux sont persistants, adaptés aux messageries, mais ils font des choix architecturaux opposés.

Une formulation claire du blog Kilo le résume : « Hermes encapsule une passerelle autour d'un agent apprenant. OpenClaw encapsule un agent autour d'une passerelle de messagerie. »

Comment c'est construit

Avant que la boucle d'apprentissage ait un sens, vous avez besoin d'une image de base de la structure d'Hermes.

Tout passe par une seule classe AIAgent dans un script run_agent.py. CLI, passerelle de messagerie, exécuteur par lots, intégration IDE : ce sont tous des points d'entrée vers le même agent central.

C'est ce qui rend l'histoire de l'indépendance de plateforme réellement fonctionnelle.

La boucle centrale est de style ReAct et synchrone. Construire le prompt système, vérifier si une compression est nécessaire, effectuer un appel API interruptible, exécuter les appels d'outils, recommencer.

Quelques détails qui compteront plus tard :

L'agent peut exécuter des commandes dans six endroits différents. Terminal local, Docker, SSH, Modal, Daytona ou Singularity. Même code, simple changement de configuration. Déplacez l'exécution de votre ordinateur portable vers un serveur GPU cloud sans toucher à rien d'autre.
Il fonctionne avec presque tous les modèles. Une couche de traduction achemine tout fournisseur vers l'un des trois formats d'API. C'est pourquoi vous pouvez passer de Claude à GPT à Gemini à Ollama local avec une seule commande sans rien casser.
L'agent a une limite stricte de 90 tours par tâche. Sans cela, un agent bloqué dans une boucle (réessayer une API qui échoue, relire le même fichier) brûlerait silencieusement vos crédits. Les sous-agents partagent le même budget, donc une chaîne de délégation incontrôlée ne peut pas passer non plus.

C'est suffisant pour le cadre. Passons maintenant à la partie intéressante.

Avant la mémoire : Qui est l'agent ?

Avant d'aborder la mémoire et les compétences auto-évolutives, il y a une couche qui se situe au-dessus des deux : l'identité.

La mémoire est ce que l'agent sait. Les compétences sont comment il fait les choses. Mais ni l'une ni l'autre ne dit qui il est quand il se présente. Sans couche d'identité, chaque agent ressemble au même agent portant des chapeaux différents.

Hermes résout cela avec un seul fichier : SOUL.md.

Il se trouve dans ~/.hermes/SOUL.md et occupe la position n°1 dans le prompt système, avant tout autre chargement. Il définit la personnalité, le ton, le style de communication et les limites strictes de l'agent.

SOUL.md est rédigé à la main et statique. Vous l'écrivez une fois, le retouchez au fil du temps, et il reste cohérent à travers chaque projet et chaque session. Si le fichier est manquant, Hermes revient à une identité par défaut intégrée.

Pourquoi cela est-il important pour l'histoire de l'auto-amélioration ? Parce que tout ce qui suit (la mémoire que l'agent écrit, les compétences qu'il crée, la façon dont il consolide les connaissances) se fait à travers le prisme de cette identité.

SOUL.md est le cadre fixe. La mémoire et les compétences sont les parties mobiles à l'intérieur.

Le système de mémoire : Trois niveaux, trois vitesses

Hermes n'a pas une seule « mémoire ». Il a trois couches, chacune conçue pour un objectif différent.

Niveau 1 : Deux minuscules fichiers Markdown.

Au cœur se trouvent deux fichiers stockés sur disque :

MEMORY.md (2 200 caractères max) contient les notes de l'agent sur votre environnement, les conventions de projet, les bizarreries des outils et les leçons appris.
USER.md (1 375 caractères max) contient votre profil : nom, préférences de communication, niveau de compétence et choses à éviter.

Les deux sont injectés dans le prompt système sous forme d'instantané figé au début d'une session. Si l'agent écrit une nouvelle entrée de mémoire en cours de session, ce changement persiste immédiatement sur disque mais n'appara pas dans le prompt système avant la session suivante.

Lorsque la mémoire se remplit (~80 % de capacité, affiché en pourcentage dans l'en-tête du prompt système), l'agent doit consolider.

Il fusionne les entrées connexes en versions plus denses et plus riches en informations, de sorte que seules les informations utiles survivent.

Niveau 2 : Recherche en texte intégral dans les sessions.

Chaque conversation (CLI et messagerie) est stockée dans SQLite avec recherche en texte intégral. L'agent peut rechercher des semaines de conversations passées.

Le compromis est clair : le niveau 1 est toujours dans le contexte mais minuscule. Le niveau 2 a une capacité illimitée mais nécessite une recherche active plus un résumé par LLM.

Les faits critiques vivent dans la mémoire. Tout le reste est consultable à la demande.

Niveau 3 : Fournisseurs de mémoire externes (8 plugins).

Pour une mémoire persistante plus profonde, Hermes est livré avec 8 fournisseurs enfichables qui fonctionnent en parallèle de la mémoire intégrée (sans jamais la remplacer). Un seul peut être actif à la fois.

Lorsqu'un fournisseur externe est actif, Hermes récupère automatiquement les mémoires pertinentes avant chaque tour, synchronise les tours de conversation après chaque réponse et extrait les mémoires à la fin de la session.

Compétences auto-évolutives : L'agent écrit ses propres playbooks

La mémoire gère les faits. Les compétences gèrent les procédures.

Les compétences sont des fichiers Markdown avec un frontmatter YAML, et fonctionnent comme la mémoire procédurale de l'agent : non pas ce qu'il sait, mais comment il fait les choses.

Voici l'anatomie d'une compétence :

Pour maintenir les coûts de tokens bas, les compétences utilisent une divulgation progressive :

Niveau 0 : L'agent voit les noms + descriptions uniquement (~3k tokens pour le catalogue complet)
Niveau 1 : Il charge le contenu complet de la compétence lorsqu'il en a réellement besoin
Niveau 2 : Il peut explorer des fichiers de référence spécifiques au sein d'une compétence

La boucle d'auto-amélioration.

C'est le différenciateur principal. L'agent crée ses propres compétences de manière autonome à l'aide de l'outil skill_manage. La création de compétences se déclenche lorsque :

L'agent termine une tâche complexe (5+ appels d'outils)
Il rencontre des erreurs ou des impasses et trouve la voie qui fonctionne
L'utilisateur corrige son approche
Il découvre un flux de travail non trivial

La boucle fonctionne donc ainsi : l'agent rencontre un problème → le résout par essais et erreurs → enregistre l'approche réussie dans un fichier SKILL.md → la prochaine fois qu'il rencontre un problème similaire, il charge la compétence et suit la procédure éprouvée au lieu de redécouvrir l'approche partir de zéro.

L'outil prend en charge six actions : create, patch (correctif ciblé, préféré car économe en tokens), edit (réécriture complète), delete, write_file et remove_file.

Le Curateur : le ramasse-miettes pour les compétences.

Sans maintenance, les compétences créées par l'agent s'accumulent. Vous vous retrouvez avec des dizaines de playbooks étroits et qui se chevauchent, gaspillant des tokens et polluant le catalogue.

Le Curateur est un système de maintenance en arrière-plan qui gère cela. Il se déclenche sur une vérification d'inactivité (pas un démon cron) : si 7 jours se sont écoulés depuis la dernière exécution et que l'agent est inactif depuis 2 heures ou plus, une fourche en arrière-plan de l'agent se lance avec son propre cache de prompts, sans jamais toucher à la conversation active.

Il fonctionne en deux phases :

Transitions automatiques (déterministes, sans LLM) : Les compétences inutilisées depuis 30 jours deviennent obsolètes. Les compétences inutilisées depuis 90 jours sont archivées.
Révision par LLM (jusqu'à 8 itérations) : Un agent fourché inspecte toutes les compétences créées par l'agent et décide par compétence de les conserver, corriger, consolider ou archiver.

Deux contraintes importantes :

Le Curateur ne touche jamais les compétences groupées ou installées depuis le hub. Seules celles créées par l'agent.
Il ne supprime jamais automatiquement. Le pire résultat est l'archivage dans ~/.hermes/skills/.archive/, qui est récupérable avec une seule commande.

Avant chaque passage du Curateur, Hermes prend un instantané tar.gz de tout le répertoire des compétences. Le retour en arrière est une commande, et les retours en arrière sont eux-mêmes réversibles.

Vous pouvez également épingler les compétences critiques avec hermes curator pin <skill> pour les protéger de l'archivage et de la suppression. Les correctifs et les modifications passent toujours, donc l'agent peut améliorer une compétence épinglée sans que vous ayez à la désépingler d'abord.

GEPA : Faire évoluer les compétences hors ligne avec des traces d'exécution

C'est là que ça devient intéressant.

La boucle d'apprentissage dans l'agent (création de compétences + Curateur) a une faiblesse connue :

L'agent a tendance à l'auto-félicitation. Il pense presque toujours avoir bien performé, même quand ce n'est pas le cas. Les retours de la communauté l'ont confirmé.
Le même système qui génère automatiquement des compétences peut également écraser les personnalisations manuelles avec des versions moins bonnes.

C'est là que GEPA intervient.

GEPA (Genetic-Pareto Prompt Evolution) n'est pas intégré dans l'exécution d'Hermes. Il vit dans un dépôt compagnon (NousResearch/hermes-agent-self-evolution) et fonctionne comme un pipeline d'optimisation hors ligne. Publié en tant qu'article ICLR 2026 Oral, sous licence MIT.

L'idée centrale : au lieu de demander à l'agent « as-tu bien fait ? », GEPA lit les traces d'exécution pour comprendre pourquoi les choses ont échoué, puis propose des améliorations ciblées via une recherche évolutive.

Le pipeline :

Lire la compétence actuelle depuis le dépôt Hermes
Générer un jeu de données d'évaluation (cas de test synthétiques via Claude Opus, historique de sessions réel depuis SQLite, ou ensembles de référence sélectionnés manuellement)
Exécuter l'optimiseur GEPA : lire les traces d'exécution → comprendre les points d'échec → générer des variantes candidates
Évaluer les candidates à l'aide d'une notation LLM-as-judge avec des rubriques (pas un succès/échec binaire)
Appliquer des contraintes : la suite de tests complète doit réussir à 100 %, les compétences restent sous 15 Ko, la compatibilité du cache est préservée, l'objectif sémantique ne dérive pas
La meilleure variante sort sous forme de PR contre le dépôt Hermes. Jamais un commit direct.

Aucun GPU requis. Tout se fait via des appels API. Coût : environ 2 à 10 $ par exécution d'optimisation.

C'est quelque chose que vous pouvez ignorer au début, mais très efficace lorsque vous butez sur un mur et que vous ne voulez pas passer du temps et de l'argent sur le réglage fin (RL/GRPO).

Plus de détails dans ce dépôt →

J'ai récemment écrit un article sur GEPA.

C'est une excellente alternative à essayer avant de passer à un réglage fin complet ou basé sur RL.

Bon, pour résumer :

SOUL.md définit l'identité. La boucle d'exécution capture l'expérience. Le Curateur garde la bibliothèque propre. GEPA s'assure que ce qui se trouve dans la bibliothèque fonctionne réellement.

Voilà toute la théorie. Maintenant, faisons-la fonctionner sur votre machine.

Mise en route

Linux, macOS ou WSL2. Python 3.11+ est fourni avec l'installateur. 8 Go de RAM suffisent pour une utilisation basée sur API.

Installation en une ligne :

Lancez l'assistant de configuration. Il vous guide à travers le fournisseur, la clé API, le modèle et les outils :

Commencez à discuter dans le terminal :

Connectez-le à Telegram :

Si vous voulez parler à votre agent depuis votre téléphone au lieu du terminal, pointez-le vers un bot Telegram.

Obtenez un jeton de bot auprès de @BotFather (exécutez /newbot), puis obtenez votre ID utilisateur Telegram auprès de @userinfobot.

C'est tout. Vous avez un agent fonctionnel :

Ce qui se trouve dans ~/.hermes/

Juste après l'installation, votre répertoire d'accueil reçoit un nouveau dossier.

Il est utile de comprendre la disposition car tout ce que vous faites avec Hermes touche l'un de ces chemins.

Quelques fichiers méritent un examen plus attentif.

config.yaml est la source de vérité pour tout ce qui n'est pas secret. Choix du modèle, backend terminal, activation des outils, serveurs MCP, tout se trouve ici. Modifiez avec hermes config edit ou définissez des valeurs une par une avec hermes config set <key> <value>.
.env contient vos secrets. Clés API, jetons de bot, mots de passe. Hermes achemine automatiquement les valeurs qui ressemblent à des secrets ici.
SOUL.md est la position n°1 dans le prompt système, avant tout le reste. Couche d'identité, vue plus haut.
skills/ est l'endroit où vit toute la boucle d'apprentissage. Toute compétence créée par l'agent, plus tout ce que vous installez, atterrit ici.
state.db est la base de données SQLite qui alimente la recherche de sessions. Mode WAL-safe, indexé FTS5. C'est ce qui rend la question « de quoi avons-nous parlé il y a trois semaines ? » réellement fonctionnelle.

Vous ne modifierez pas la plupart de ces fichiers manuellement. Mais connaître la disposition rend tout le reste plus clair.

Ajouter de nouvelles compétences

Hermes maintient son propre Skills Hub officiel avec 687 compétences dans 18 catégories. La répartition :

87 compétences intégrées livrées avec l'agent
79 compétences optionnelles que vous pouvez activer à la demande
16 d'Anthropic (frontend-design, pdf, pptx, docx, mcp-builder, etc.)
505 de LobeHub (contributions plus larges de la communauté élargie)

Vous pouvez également ajouter n'importe quel dépôt GitHub en tant que tap personnalisé :

C'est ainsi que vous partageriez des compétences au sein d'une équipe ou que vous maintiendriez votre propre collection privée.

Passer de 1 à 10 agents

Un agent, c'est bien. Plusieurs agents spécialisés, c'est là qu'Hermes devient intéressant.

Hermes dispose d'une fonctionnalité de première classe pour cela appelée profils. Chaque profil est une instance Hermes totalement isolée avec sa propre configuration, mémoire, compétences, sessions et SOUL.md. Ils ne partagent rien par défaut.

Nous allons en mettre en place trois : un designer, un programmeur et un chercheur.

Créer une équipe

<block>

<p>--clone copie la configuration et le .env de votre profil par défaut comme point de départ.</p>

</blockquote>

Donner à chacun son propre bot Telegram

Chaque profil a besoin de son propre bot de BotFather. Telegram n'autorise qu'une seule connexion par jeton, donc le partage casse les choses.

Exécutez /newbot trois fois avec BotFather et sauvegardez les trois jetons. Ensuite, exécutez l'assistant de passerelle une fois par profil :

La configuration est exactement la même que pour un agent classique, où vous pouvez à nouveau créer de nouveaux bots dans BotFather et les connecter à leurs agents respectifs.

Donner à chacun une personnalité via SOUL.md

C'est là que les agents deviennent vraiment différents les uns des autres. Modifiez le SOUL.md de chaque profil.

Designer dans ~/.hermes/profiles/designer/SOUL.md :

Regardez ces exemples :

Programmeur dans ~/.hermes/profiles/programmer/SOUL.md :

Chercheur dans ~/.hermes/profiles/researcher/SOUL.md :

Personnaliser le programmeur : acheminer l'exécution via Claude Code

Le programmeur est plus intéressant s'il ne se contente pas d'écrire du code lui-même, mais délègue l'exécution à l'interface Claude Code. Hermes orchestre. Claude Code effectue les modifications de fichiers, exécute les commandes, gère git. Hermes lit le résultat et décide de la suite.

C'est aussi comme ça que je fais fonctionner le mien par-dessus mon abonnement Claude Max. Pas de clé API séparée. Claude Code utilise automatiquement les identifiants Max.

Démarrez une session et envoyez ce prompt d'activation unique :

J'ai déjà un abonnement Claude Max. Vous êtes mon ingénieur staff qui

m'aide dans mes tâches de codage quotidiennes, et sous le capot, vous utilisez

vous utilisez Claude Code pour toutes les exécutions. Configurez-vous en conséquence.

Le programmeur installera la compétence autonomous-ai-agents/claude-code tout seul, vérifiera que claude est dans le PATH, et commencera à l'utiliser pour l'exécution du code. À partir du message suivant, tout ce qui est lié au codage (lire des fichiers, écrire du code, exécuter des tests, commit, push) sera acheminé via Claude Code en arrière-plan.

Deux choses à savoir :

Assurez-vous que claude est dans votre PATH avant l'activation. which claude doit affiche un chemin binaire réel.
Claude Code a à la fois un mode d'impression (one-shot, rapide, sans TUI) et un mode interactif (session tmux complète). Le programmeur choisit en fonction de la tâche. Vous n'avez pas besoin d'y penser.

Personnaliser le designer : lui enseigner votre style visuel

Le designer devient vraiment utile lorsqu'il peut générer des images dans votre style, et non une sortie IA générique. Le modèle : lui fournir des designs de référence, le laisser les étudier, lui demander de créer une compétence qui génère de nouvelles images dans le même style.

C'est la boucle d'auto-amélioration utilisée comme mécanisme de configuration. Au lieu d'écrire une compétence à la main, vous montrez à l'agent de bons exemples et lui demandez d'encoder le modèle lui-même.

Démarrez une session avec le designer et collez vos images de référence (glisser-déposer dans la CLI, ou joindre dans Telegram). Ensuite, envoyez ce prompt :

Le designer étudiera les références, écrira le SKILL.md, générera le script Python, le sauvegardera dans ~/.hermes/profiles/designer/skills/my-design-style/, et vérifiera que le script s'exécute.

Si vous avez déjà exécuté hermes setup et choisi OpenRouter comme fournisseur, la clé est déjà dans le .env du profil designer grâce à --clone. Sinon, ajoutez-la une fois :

À partir de là, demander une nouvelle illustration au designer déclenche la compétence. Il écrit un prompt basé sur votre empreinte de votre style, appelle Nano Banana via OpenRouter et sauvegarde la sortie.

Le même modèle fonctionne pour toute sortie nécessitant un style spécifique. Fournissez du contenu de référence, demandez à l'agent de construire une compétence qui reproduit le modèle. Introductions de newsletter, fils X, commentaires de revue de code, tout ce qui nécessite de la cohérence.

Planifier le travail : Cron en anglais simple

Le SOUL.md du chercheur indique qu'il est responsable d'un résumé quotidien sur Telegram. Cela implique une tâche qui s'exécute selon son propre calendrier, sans que vous ayez à le demander. C'est à cela que sert Hermes cron.

Hermes est livré avec un planificateur intégré. Le démon de la passerelle tique toutes les 60 secondes, exécute les tâches dues dans des sessions d'agent isolées et livre la sortie à la plateforme de messagerie que vous spécifiez. Les tâches survivent aux redémarrages. Elles vivent dans ~/.hermes/cron/jobs.json et la sortie va dans ~/.hermes/cron/output/.

La partie intéressante : vous n'écrivez pas d'expressions cron. Vous décrivez ce que vous voulez en anglais et Hermes le convertit.

Configurez le résumé quotidien du chercheur

Ouvrez une session avec le chercheur et envoyez ce prompt :

Le chercheur crée la tâche à l'aide de son outil cronjob, la cible de livraison par défaut est le chat actuel (Telegram dans ce cas), et le planificateur prend le relais. Vérifiez qu'elle a été créée :

Vous devriez voir la tâche avec sa prochaine heure d'exécution prévue. Demain matin à 8h, votre Telegram s'allume avec le résumé. Aucune action supplémentaire nécessaire.

Autres modèles utiles

La syntaxe cron est flexible. Quelques variantes à connaître :

Délais uniques. /cron add 30m "30m" "Rappelle-moi de vérifier la build" s'exécute une fois dans 30 minutes.
Intervalles récurrents. /cron add "toutes les 2h" "Vérifier le statut du serveur" s'exécute toutes les deux heures.
Expressions cron standard. /cron add "0 9 1-5" "..." pour un contrôle précis. Jours de semaine à 9h, dans ce cas.
Attachement de compétence. /cron add "toutes les 1h" "Résumer les nouveaux éléments du flux" --skill blogwatcher charge une compétence avant d'exécuter le prompt.

Vous pouvez également chaîner des tâches. La sortie d'un cron devient l'entrée du cron suivant via un indicateur context_from. Utile pour les automatisations en plusieurs étapes où vous souhaitez qu'une étape de recherche alimente une étape d'écriture.

C'est tout.

Merci d'avoir lu. Dites-moi dans les commentaires ce que vous souhaiteriez que je couvre la prochaine fois.

Si vous apprenez mieux par la vidéo, je publie une démonstration complète d'Hermes Agent sur YouTube et X dans quelques jours.

Restez à l'écoute !

À bientôt ! :)