Guide complet de l'agent Hermes : architecture, configuration et boucle d'auto-amélioration

Il y a une nouvelle catégorie d'outils d'IA qui prend forme discrètement : des agents qui ne vivent pas dans une fenêtre de chat que vous ouvrez et fermez, mais qui tournent en continu dans le cloud et vous parlent via une messagerie, comme un collègue qui ne se déconnecte jamais.

Hermes est l'une des implémentations les plus intéressantes de cette idée, et ce qui le distingue d'agents comparables comme OpenClaw, c'est une boucle d'auto-amélioration intégrée – un système qui surveille vos conversations, en extrait des schémas utiles et transforme ces schémas en améliorations permanentes de sa propre mémoire et de ses compétences.

Cet article explique comment Hermes est construit, comment le configurer et comment cette boucle d'auto-amélioration fonctionne réellement sous le capot.

Ce qu'est Hermes et en quoi il diffère d'OpenClaw

Hermes est un agent d'IA résidant dans le cloud, structurellement similaire à OpenClaw : il fonctionne 24h/24 et 7j/7, et vous interagissez avec lui via une application de messagerie plutôt que via un terminal ou un onglet de navigateur.

Les différences significatives sont au nombre de trois.

Premièrement, Hermes est livré avec une bibliothèque de compétences intégrées beaucoup plus vaste, ce qui vous évite de devoir configurer vous-même les intégrations.

Deuxièmement, le processus d'installation est considérablement plus simple – une interface textuelle guidée s'occupe de presque tout.

Troisièmement, et c'est le point le plus important, Hermes est conçu pour une amélioration continue : il n'exécute pas seulement des tâches, il accumule des connaissances procédurales sur la façon de les exécuter plus efficacement au fil du temps.

Installation et configuration initiale

Pour faire fonctionner Hermes, une seule commande suffit.

Sous Windows, vous exécutez ceci dans PowerShell :

iex (irm

https://hermes-agent.nousresearch.com/install.ps1

Sous Linux, macOS ou WSL, l'équivalent est :

curl -fsSL

https://hermes-agent.nousresearch.com/install.sh | bash

Une fois installé, redémarrez le terminal et exécutez hermes setup pour lancer un processus de configuration guidée qui vous accompagne dans le choix du modèle, du backend du terminal, de la passerelle de messagerie et de la configuration des outils.

Choix et routage des modèles

La première vraie décision lors de la configuration est de choisir quel fournisseur de LLM alimente le « cerveau » de l'agent. L'authentification se fait via OAuth plutôt qu'avec des clés API brutes, ce qui permet de se connecter via une session Claude Code ou Codex CLI existante, plutôt que de générer une clé API distincte.

Ce qui est vraiment bien conçu ici, c'est la façon dont Hermes sépare le modèle utilisé pour votre conversation principale des modèles utilisés pour les tâches d'arrière-plan et auxiliaires. Par défaut, le même modèle gère les deux, mais chaque tâche auxiliaire peut être pointée vers un fournisseur différent de manière indépendante.

Les tâches qui prennent en charge ce type de remplacement sont :

• vision – analyse et description d'images
• web_extract – résumé de longues pages web
• compression – compression d'un contexte de conversation qui déborde
• title_generation – génération de titres de session
• curator – l'agent d'arrière-plan responsable de la boucle d'auto-amélioration
• kanban_decomposer – décomposition de grandes tâches en sous-tâches en mode Kanban
• goal_judge – l'agent qui vérifie si un /goal a réellement été atteint

Ceci est configuré directement dans config.yaml, par exemple :

1# Primary model for chat and complex reasoning
2model:
3  provider: "anthropic"
4  default: "claude-4-8-sonnet"
5  auxiliary:
6    vision:
7      provider: "gemini"
8      model: "gemini-2.5-flash"
9    compression:
10      provider: "custom"
11      base_url: "http://localhost:11434/v1"
12      api_key: "none"
13      model: "qwen2.5:32b"

Ce type de routage explicite résout un vrai problème avec OpenRouter comme choix par défaut : le même modèle nominal est souvent déployé par de nombreux fournisseurs différents, souvent dans des quantifications différentes, et OpenRouter va mélanger silencieusement chaque nouvelle requête entre environ vingt d'entre eux.

L'effet pratique est qu'au sein d'une même session, vous ne parlez pas à un modèle cohérent – vous parlez à une série tournante d'instances configurées différemment de ce modèle, dont certaines gèrent les appels d'outils et les templates de prompts de manière plus fiable que d'autres. Le routage manuel dans Hermes évite complètement ce problème.

Il est également utile de noter que si vous souhaitez économiser de l'argent sur le modèle conversationnel sans sacrifier la qualité du codage, Hermes prend en charge les commandes /claude_code et /codex qui délèguent les tâches de codage directement à ces outils CLI plutôt que de les gérer avec le modèle de chat configuré.

Backends de terminal

Un élément central de l'architecture est l'environnement de backend de terminal, qui détermine où et comment les commandes shell et les scripts Python s'exécutent réellement, et comment l'agent accède à votre système de fichiers. Hermes en prend en charge cinq.

Local est le défaut. Les commandes s'exécutent directement sur votre machine avec les mêmes autorisations que votre compte utilisateur – aucune isolation. C'est le bon choix pour le développement local et l'usage personnel de confiance où vous souhaitez que l'agent modifie vos fichiers de projet réels.

La sécurité repose ici entièrement sur un système d'approbation intégré qui intercepte les commandes destructrices (un rm -rf /, un DROP TABLE) et demande une autorisation explicite avant de les exécuter.

Docker exécute l'agent dans un bac à sable isolé afin qu'il ne puisse pas toucher à votre système hôte. SSH fait exécuter les commandes et travailler sur les fichiers de l'agent sur un serveur distant via une connexion distante. Modal exécute tout dans des bacs à sable cloud sans serveur – vous louez essentiellement du calcul à la seconde, en ne payant que pour les secondes réelles où votre code s'exécute.

Daytona est une couche de gestion de conteneurs spécialement conçue pour les agents de codage IA ; c'est plus rapide que d'utiliser Docker directement et gère automatiquement la configuration de l'environnement et l'installation des dépendances.

Pour la plupart des cas d'usage personnels, Local est vraiment suffisant – les autres options comptent principalement si vous exécutez du code non fiable ou si vous opérez à l'échelle d'une équipe.

Passerelle de messagerie et configuration des outils

Après le backend du terminal, la configuration passe au choix de l'endroit où vous allez réellement parler à l'agent – Telegram étant l'option la plus aboutie. Le sélectionner vous donne un lien direct qui crée un bot pré-configuré ; aucune configuration manuelle de jeton de bot n'est nécessaire.

Le reste de la configuration vous guide à travers l'activation d'outils individuels et de leurs fournisseurs respectifs – automatisation du navigateur, génération d'images, synthèse vocale et recherche web. Pour la recherche web en particulier, Firecrawl ou Exa auto-hébergés se démarquent comme des choix solides pour le scraping et la récupération orientés agents.

La recherche X nécessite un abonnement Grok pour être activée, ce qui est bon à savoir avant de la chercher dans le menu.

Les commandes slash à connaître

Hermes est livré avec une longue liste de commandes slash, la plupart explicites par leur nom, mais quelques-unes méritent d'être mentionnées spécifiquement.

1. /background <prompt> exécute une tâche en arrière-plan sans interrompre votre session principale.
2. /goal définit un objectif à long terme vers lequel l'agent travaille de manière persistante, avec des sous-commandes pour mettre en pause, reprendre, effacer ou vérifier l'état ;
3. /subgoal gère des objectifs plus petits imbriqués sous un objectif actif.
4. /kanban orchestre un travail asynchrone de longue durée sur plusieurs agents indépendants – fonctionnant comme un véritable tableau Kanban où un ensemble de tâches est distribué entre des agents ouvriers et progresse à travers les étapes à faire, en cours et terminé au fur et à mesure qu'il est transmis entre eux.

Du côté développement, /github_pr_workflow gère le cycle complet de la branche à la fusion, y compris l'IC, /github_code_review examine les demandes de tirage, et /codebase_inspection analyse la répartition des langages et le nombre de lignes d'un dépôt. /dogfood est un mode QA dédié qui recherche des bogues dans une application web et produit un rapport étayé par des preuves. /spike exécute une expérience rapide et jetable pour valider une idée avant de s'engager dans le développement complet, et /systematic_debugging travaille sur les bogues en quatre phases, comprenant la cause profonde avant de tenter une correction.

Il existe également un ensemble de commandes spécifiques à l'intégration – /notion, /obsidian, /airtable, /google_workspace, /arxiv, /blogwatcher, /polymarket, /ocr_and_documents, /youtube_content – chacune encapsulant un service externe ou un flux de travail spécifique, plus /bundles, qui regroupe plusieurs compétences existantes sous une seule commande slash via de petits fichiers de configuration YAML.

Tâches cron et Webhooks

Deux primitives d'automatisation méritent une attention particulière.

• Les tâches cron vous permettent de planifier l'exécution d'un script à intervalles réguliers ; si vous passez -no-agent lors de la création, Hermes exécutera un script Python ou bash simple et transmettra simplement sa sortie à votre messagerie, sans utiliser aucun jeton LLM.
• Les webhooks sont l'élément le plus puissant : ils permettent à l'agent de réagir à des événements externes plutôt qu'à une minuterie. Vous pouvez configurer un webhook de sorte que, par exemple, une nouvelle demande de tirage GitHub déclenche automatiquement un agent avec un prompt et un ensemble de compétences spécifiques – mettant effectivement en place un agent de révision de garde sans aucune intervention manuelle par PR.

Moteurs de contexte

Le moteur de contexte régit la façon dont Hermes compresse et gère l'historique des conversations lorsqu'il approche de la limite de jetons du modèle, et il existe deux options.

• La valeur par défaut, appelée Compressor, applique un résumé avec perte à la partie médiane d'une longue conversation.
• L'alternative, LCM (Lossless Context Management), adopte une approche structurellement différente : au lieu de produire un résumé textuel, il construit un graphe orienté acyclique des points clés de la conversation, permettant à l'agent de naviguer d'une vue d'ensemble hautement compressée jusqu'aux messages originaux spécifiques qui la soutiennent.

Moteurs de mémoire

Les fournisseurs de mémoire externes fonctionnent parallèlement aux fichiers de mémoire locale intégrés d'Hermes, MEMORY.md et USER.md, ajoutant des capacités telles que la recherche sémantique et les graphes de connaissances.

Plusieurs peuvent être configurés directement via l'interface de configuration.

1. Honcho est conçu pour modéliser un profil utilisateur détaillé, en utilisant des appels LLM d'arrière-plan pour synthétiser les observations sur deux couches : une couche de base de résumés de session et de profils, et une couche dialectique qui analyse les besoins actuels de l'utilisateur.
2. OpenViking est une base de données de contexte qui construit une hiérarchie de connaissances de type système de fichiers, prenant en charge la récupération de contexte à plusieurs niveaux et triant automatiquement les faits extraits en six catégories – événements, modèles, préférences, etc. – à la fin de chaque session.
3. Mem0 est un service de mémoire cloud entièrement géré ; l'extraction de faits s'effectue côté serveur via LLM, et il comprend la recherche sémantique, le reclassement des résultats et la déduplication automatique, bien qu'étant hébergé dans le cloud, c'est aussi la seule option ici avec un coût récurrent.
4. Hindsight est un système de mémoire à long terme plus avancé construit sur un graphe de connaissances, dans le style GraphRAG. Il extrait des entités des sessions, établit des relations entre elles et préserve les tours de conversation complets, y compris les appels d'outils, avec une mémoire divisée en quatre catégories : les faits sur le monde, la propre expérience de l'agent, les opinions et les observations.
5. Holographic est un magasin de faits local, basé sur SQLite, sans dépendances externes, comprenant un système de notation de confiance pour les faits stockés et l'utilisation de représentations réduites holographiques pour prendre en charge les requêtes algébriques et compositionnelles, avec la capacité de détecter automatiquement les contradictions dans sa base de connaissances.
6. RetainDB est une API cloud pour la mémoire d'équipe, offrant une recherche hybride sur les méthodes vectorielles, BM25 et de reclassement, avec une mémoire divisée en sept types distincts et une compression delta pour maintenir un stockage efficace.
7. ByteRover est un système de mémoire local et portable accessible via une CLI, construisant un arbre de connaissances hiérarchique et extrayant les faits importants avant que la compression avec perte n'ait une chance de les supprimer du contexte.
8. Supermemory offre une mémoire à long terme sémantique avec une API de graphe : il ingère les journaux de session complets après la fin d'une conversation pour construire son graphe de connaissances, nettoie périodiquement les faits rappelés pour éviter la pollution par les tours en cours, et peut isoler la mémoire dans des conteneurs séparés par profil d'agent.

Pour une utilisation quotidienne, la mémoire locale par défaut est vraiment adéquate pour la plupart des gens – les systèmes plus lourds échangent un coût réel en ressources, en particulier la RAM pour les options hébergées localement, contre des capacités dont la plupart des flux de travail n'ont pas encore besoin.

La boucle d'auto-amélioration

C'est la fonctionnalité qui distingue le plus Hermes d'un agent conventionnel : un ensemble de processus d'arrière-plan asynchrones qui analysent en continu vos conversations, en extraient des schémas utiles et écrivent ces schémas dans la mémoire à long terme et la mémoire procédurale (compétences) – puis maintiennent ces connaissances accumulées afin qu'elles ne se dégradent pas avec le temps. L'ensemble du système fonctionne en parallèle de votre chat principal et est construit à partir de trois composants : un système de déclenchement, un agent de révision d'arrière-plan et un conservateur.

• Le système de déclenchement

Hermes n'analyse pas chaque message en temps réel, car cela brûlerait des jetons pour aucun bénéfice. Au lieu de cela, il s'appuie sur deux compteurs qui déclenchent un passage de réflexion une fois qu'ils franchissent un seuil.

Un déclencheur de mémoire se déclenche toutes les dix invites utilisateur, vérifiant si de nouveaux faits dignes d'être enregistrés sont apparus dans la conversation.

Un déclencheur de compétence se déclenche toutes les dix itérations d'appel d'outil au sein d'un seul tour, partant du principe que si l'agent vient de passer autant d'étapes à se battre avec un problème par essais et erreurs, cette expérience mérite d'être analysée et éventuellement transformée en une compétence réutilisable.

Une fois que l'un ou l'autre compteur atteint sa limite, une fonction interne se déclenche, transmettant un instantané de la conversation en cours à un processus de révision d'arrière-plan.

• L'agent de révision d'arrière-plan

Cet instantané est envoyé à un processus d'agent complètement séparé et isolé qui s'exécute en parallèle sans interrompre votre session principale. Il fonctionne dans deux directions.

1. Du côté déclaratif, s'il remarque de nouvelles préférences utilisateur ou des détails d'environnement – une préférence pour Supabase, un projet épinglé à Python 3.12 – il met à jour MEMORY.md ou USER.md, selon le fichier auquel le fait appartient.
2. Du côté procédural, s'il détecte que l'agent vient de résoudre un problème non trivial ou d'élaborer un processus complexe, il peut créer une nouvelle compétence, modifier une compétence existante, appliquer un correctif ciblé ou en supprimer une carrément. Toute compétence qu'il crée est explicitement étiquetée comme générée par l'agent, de sorte que son origine soit toujours traçable.

Pour que le conservateur puisse évaluer lesquelles de ces compétences auto-générées valent réellement la peine d'être conservées, Hermes maintient un journal d'utilisation caché qui suit, pour chaque compétence : combien de fois elle a été chargée dans un prompt, combien de fois l'agent l'a ouverte pour la lire, combien de fois elle a été modifiée, ainsi que les horodatages de création, de dernière utilisation et de dernière modification.

• Le conservateur

Sans contrôle, ce processus peut éventuellement produire des centaines de compétences, certaines redondantes, d'autres obsolètes.

Le conservateur existe pour empêcher cette base de connaissances de se dégrader. Il ne démarre que lorsque deux conditions sont simultanément remplies : suffisamment de temps s'est écoulé depuis sa dernière exécution (sept jours, par défaut), et l'agent principal est inactif depuis assez longtemps (deux heures, par défaut) pour qu'un passage de maintenance lourd n'interfère pas avec le travail actif.

Avant d'apporter des modifications, il sauvegarde automatiquement l'intégralité du répertoire des compétences, de sorte que tout résultat insatisfaisant puisse être annulé via une seule commande de terminal.

Le travail du conservateur se déroule en deux phases :

• La première est purement mécanique et n'implique aucun appel LLM : il vérifie les métriques d'utilisation, marque comme obsolète toute compétence générée par l'agent inutilisée depuis plus de 30 jours, et déplace tout ce qui est inutilisé depuis plus de 90 jours dans un dossier d'archive. Les compétences importantes peuvent être explicitement épinglées pour les protéger de ce processus.
• La deuxième phase est une véritable révision LLM, exécutée via une instance d'agent isolée distincte utilisant le modèle configuré pour la tâche auxiliaire du conservateur – par défaut le même modèle que la conversation principale, bien qu'il puisse être pointé vers quelque chose de moins cher. Il faut être prudent quant à l'utilisation d'un modèle trop bon marché, car la qualité de ces décisions a un véritable effet en aval sur la bibliothèque de compétences.

Pour chaque compétence, le conservateur décide de la conserver telle quelle si elle est toujours précise et utile, de la corriger si elle contient des erreurs ou des méthodes obsolètes, de la fusionner avec une autre compétence couvrant sensiblement le même domaine (en déplaçant correctement tous les scripts, évaluations ou fichiers de référence associés et en réécrivant les chemins relatifs dans le processus), ou de l'archiver complètement.

À la fin du cycle, il produit un rapport détaillé comprenant une carte de renommage montrant exactement comment les anciens noms de compétences correspondent aux nouveaux après d'éventuelles fusions, de sorte que le raisonnement derrière chaque décision soit entièrement vérifiable.

Bien utiliser Hermes

Les agents cloud comme celui-ci sont vraiment précieux pour tout processus que vous pouvez exécuter 24h/24 et 7j/7 – le travail de codage étant l'exception notable – à condition que vous ayez effectivement numérisé ce processus avec soin et construit une compétence solide autour de lui, y compris des évaluations.

Le flux de travail qui tend à produire de bons résultats ressemble à ceci :

1. Commencez par vous enregistrer, en détail, en parcourant le processus du début absolu à la fin, idéalement en utilisant un outil de dictée pour le capturer avec précision – et cette étape ne fonctionne que si vous comprenez vraiment le processus ou si vous l'avez correctement recherché.
2. Prenez cet enregistrement ou ces notes et introduisez-les dans un agent de codage en utilisant un outil de création de compétence pour produire une première ébauche ; elle ne sera pas encore assez bonne pour être déléguée, surtout pour quoi que ce soit de complexe.
3. Intégrez des évaluations – des solutions de référence qui représentent un résultat correct – car ce sont elles qui vous permettent de mesurer réellement si la compétence fonctionne bien plutôt que de deviner.
4. Exécutez la compétence dans un environnement de test et affinez à la fois les évaluations et le contenu de la compétence en fonction de ce que vous observez, en effectuant la majeure partie de cette édition à la main plutôt qu'en la déléguant.
5. Ce n'est qu'une fois que la compétence se comporte de manière cohérente et déterministe qu'elle doit être confiée à l'agent toujours actif. Si le processus dépend d'un service externe, il vaut la peine de vérifier si un serveur MCP ou une CLI existant le couvre déjà avant d'en construire un à partir de zéro.

Le point plus large est que l'éventail des choses que vous pouvez confier à un agent comme celui-ci est limité principalement par votre capacité à spécifier le travail, et non par la capacité brute de l'agent.

Trois principes semblent tenir dans tous les cas d'usage : ne déléguez pas le travail de codage à un agent cloud non supervisé 24h/24 et 7j/7, gardez un humain dans la boucle pour examiner ce que l'agent produit réellement, et considérez le perfectionnement des compétences comme un travail continu plutôt que comme quelque chose que vous terminez une fois et dont vous vous éloignez.

Si cela a été utile – mettez-le en signet. Vous voudrez y revenir.

Pour plus d'analyses comme celle-ci, suivez @ScottyBeamIO

Sans fioritures, seulement ce qui fonctionne réellement.