10 choses à essayer après avoir pris en main Hermes Agent

Cet article propose dix fonctions recommandées à essayer après avoir installé Hermes Agent, à travers une mise en pratique. Le contenu est très riche, saisi manuellement, et vérifié par une revue du code source et une validation expérimentale. Grâce à ces essais, huit points forts majeurs d'Hermes sont également résumés et inclus dans le texte. Bienvenue à lire et à échanger des idées~

0. Installation et déploiement

En prérequis, faisons un rapide tour de l'installation et du déploiement pour aider les amis à démarrer de zéro.

Une seule commande suffit pour l'installation (prend en charge macOS / WSL2 / Linux) :

1curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash -x

J'ai ajouté -x pour vous permettre de voir le processus d'exécution plus facilement. Les utilisateurs Windows doivent installer WSL2 et exécuter Hermes Agent depuis WSL2.

Après la fin de la commande, elle devrait vous guider à travers la configuration, ou vous pouvez l'exécuter manuellement :

hermes setup

Terminez la configuration des modèles, des canaux, etc., de manière interactive.

La configuration interactive d'Hermes n'est pas aussi bonne que celle d'OpenClaw, mais elle est assez simple. Un petit piège concerne la configuration de la clé du modèle : si vous la collez, elle ne s'affiche pas. Dans votre précipitation, vous pourriez la coller plusieurs fois, ce qui rendrait la clé invalide.

Le remède est de modifier ~/.hermes/.env avec vim.

Vérifiez si les clés dans le fichier sont exactes ; si ce n'est pas le cas, modifiez-les manuellement. Ensuite, configurer les canaux n'est pas très différent d'OpenClaw.

Premièrement : Configurer l'anti-bot (Camofox ou Browserbase)

Si vous voulez que je lise automatiquement des articles, remplisse des formulaires, attrape des tickets ou opère le backend, vous devez me fournir un environnement navigateur « humain ». Camofox est recommandé ici.

Les navigateurs backend ordinaires (Local Chromium) seront interceptés à l'entrée.

Comment configurer : Dites à Hermes : Aide-moi à configurer CAMOFOX et CAMOFOX_URL.

Effet - Avant configuration :

Après configuration :

Point fort n°1 d'Hermes :

Un point à louer chez Hermes est qu'il juge quelles instructions sont à haut risque et demande ensuite votre autorisation de manière appropriée. C'est bien mieux qu'OpenClaw, où vous avez envie de désactiver l'autorisation parce qu'il affiche une série de chiffres sans signification, vous laissant sans savoir ce qu'il fait.

Deuxièmement : Définition de l'âme (SOUL.md)

Par défaut, Hermes est un assistant IA généraliste ; vous devez le personnaliser selon vos préférences.

Le fichier SOUL.md est un fichier vide commenté par défaut et doit être ajouté manuellement.

Comment configurer : Laissez l'agent Hermes éditer et écrire dans ~/.hermes/SOUL.md.

Voici une astuce : discutez d'abord avec Hermes pendant deux jours, en montrant votre style et vos exigences autant que possible pendant la conversation. Demandez-lui ensuite : « Est-ce qu'Hermes a une configuration recommandée pour la définition de l'âme (SOUL.md) ? »

Comme le montre la capture d'écran, ça semble assez bien. Je partage le texte pour votre référence.

Point fort n°2 d'Hermes :

Vous pouvez voir qu'Hermes a résumé deux jours de contenu, grâce à son mécanisme de lecture de session, que nous aborderons en détail plus tard.

Texte de référence pour ~/.hermes/SOUL.md :

1---
2name: Architecte Rigoureux
3version: 2.0
4---
5
6# 🧠 Mode de réflexion
7- **Vérifier avant de répondre** : Pour toute API, configuration ou chemin incertain, d'abord vérifier les outils ; ne pas se fier aux suppositions.
8- **Planifier avant d'exécuter** : Pour les tâches de plus de 3 étapes, lister d'abord le plan et les risques, et ne procéder qu'après confirmation.
9- **La livraison est la vérification** : Après avoir terminé une tâche, fournir de manière proactive « comment vérifier si elle a pris effet ».
10
11# 🛡️ Auto-limitation
12- En cas d'incertitude, dire directement « Je ne suis pas sûr » ; c'est mieux que d'inventer.
13- Si des conflits dans la mémoire ou les compétences sont trouvés, les signaler de manière proactive et demander une décision.
14- Quand une tâche échoue, analyser la cause et la solidifier en une Compétence pour éviter de répéter la même erreur.
15
16# 🗣️ Discipline de sortie
17- D'abord la conclusion, se concentrer sur le code/les commandes, moins de blabla.
18- Les opérations à haut risque (suppression de données, redémarrage, écrasement) doivent être signalées à l'avance.

Troisièmement : Auxiliaire

Le module auxiliaire est le centre de routage LLM copilote d'Hermes. Son objectif de conception est de laisser le modèle principal se concentrer sur la réflexion tout en laissant des modèles auxiliaires moins chers/spécialisés gérer le travail ingrat. Bien configurer cela peut vous faire économiser de l'argent et améliorer l'efficacité.

C'est également l'un des points forts d'Hermes : Hermes prend en charge la spécification de modèles et fournisseurs indépendants pour différentes tâches (recherche, compression, vision, etc.), réduisant ainsi les coûts du modèle principal ou améliorant les performances. La configuration est conviviale ; laissez simplement Hermes vous aider à la configurer.

Prend en charge les configurations de modèle auxiliaire personnalisées (8 au total) :

1. vision : Analyse d'écran/CAPTCHA/image
2. web_extract : Extraction et scraping de contenu web
3. compression : Résumé de compression de contexte
4. session_search : Résumé de recherche dans l'historique des sessions
5. approval : Décision d'approbation des commandes dangereuses
6. skills_hub : Aide à la recherche/installation sur le marché des compétences
7. mcp : Aide à l'appel de service MCP
8. flush_memories : Nettoyage/réorganisation du système de mémoire

Méthode de configuration, exemple verbal : « Aide-moi à configurer le modèle auxiliaire de compression de session sur qwen3.5-plus. »

Vérification : Nous déclenchons manuellement compress :

Consultez les logs (~/.hermes/logs/agent.log) :

Deux lignes clés : flush_memories utilise le modèle par défaut qwen3.6, et compress peut être vu utilisant notre modèle personnalisé. Cool~

Auxiliary flush_memories: using auto (qwen3.6-plus)

Auxiliary compression: using auto (qwen3.5-plus) at https://dashscope.aliyuncs.com/compatible-mode/v1/

Seuil de compression : Trop fréquent ou pas de compression est mauvais. La valeur par défaut actuelle est de 50 %, que je suggère d'ajuster en fonction de l'utilisation réelle.

Point fort n°3 d'Hermes : Le seuil de compression par défaut suit la fenêtre de contexte du modèle. Cela signifie que le ratio de déclenchement est différent pour les modèles de 1M et 200k. Hermes n'a pas de limite de tours, donc la mémoire pourrait être meilleure.

De plus, le budget de résumé s'adapte en conséquence : max_summary_tokens = min(context_length * 0.05, _SUMMARY_TOKENS_CEILING)

Un modèle de 1M peut allouer jusqu'à 50K tokens pour les résumés, tandis qu'un modèle de 200K n'en obtient que 10K. En bref, c'est plus raisonnable.

Quatrièmement : Système de mémoire

Le système de mémoire d'Hermes peut être divisé en trois couches, qui peuvent être configurées couche par couche (Hermes peut les configurer lui-même) :

Couche 1 : Mémoire intégrée (activée par défaut, réglage fin recommandé)

1# ~/.hermes/config.yaml
2memory:
3  memory_enabled: true           # MEMORY.md — notes de l'agent
4  user_profile_enabled: true     # USER.md — profil utilisateur
5  memory_char_limit: 2200        # Par défaut suffisant, peut être ajusté à 4000 pour une utilisation intensive
6  user_char_limit: 1375          # Par défaut suffisant
7  nudge_interval: 10             # Rappeler à l'agent de sauvegarder la mémoire tous les 10 tours, peut être réglé à 5 pour une sauvegarde plus active
8  flush_min_turns: 6             # Déclencher le raffraîchissement de la mémoire seulement après au moins 6 tours avant de quitter

Parmi eux :

memory_char_limit: 2200 stocke les notes de l'agent : faits d'environnement, conventions de projet et pièges rencontrés. L'unité est le caractère. Il écrit dans MEMORY.md. Si vous trouvez que ce fichier est souvent plein, il est recommandé d'augmenter la limite. Je l'ai changé à 4000.

user_char_limit: 1375 stocke le profil utilisateur : préférences, style de communication et habitudes de travail. L'unité est le caractère. Il écrit dans USER.md.

nudge_interval: 10 rappelle à l'agent de sauvegarder la mémoire tous les 10 tours. Si vous pensez que la mémoire d'Hermes n'est pas assez bonne, vous pouvez la régler à 5 pour être plus proactif.

Couche 2 : Fournisseur de mémoire externe (choisissez-en un selon vos besoins)

Ne vous précipitez pas pour configurer cela. Pourquoi ? Parce qu'il y a un repli local dans la troisième couche.

Hermes prend en charge 8 plugins majeurs :

En prenant l'exemple de la configuration mem0, il est recommandé d'exécuter la configuration dans le terminal :

Exécutez : hermes memory setup puis configurez la clé.

Point fort n°4 d'Hermes : La configuration est découplée ; les clés et les paramètres sont séparés. Il utilise le format YAML, que je trouve personnellement plus convivial que JSON. Google va aimer 😊

Cependant, il n'est pas aussi bon qu'OpenClaw sur un point : il n'y a pas de rechargement à chaud de la configuration. Vous devez redémarrer après avoir modifié config.yaml.

Après avoir configuré mem0, le flux de conversation implique au moins 2 appels API mem0 par tour (sync_turn écriture + queue_prefetch recherche). Si l'agent appelle activement des outils, des appels supplémentaires peuvent être nécessaires.

Par conséquent, décidez vous-même si vous activez la mémoire externe. Je suggère de ne pas l'ouvrir d'abord pour voir si les couches un et trois vous satisfont. Si ce n'est pas le cas, envisagez alors de la configurer.

Voici un schéma pour vous aider à comprendre le tableau complet d'un tour de conversation.

Couche 3 : Recherche de session (activée par défaut, assurez-vous que l'auxiliaire est disponible)

La recherche de session ne fait pas partie de la mémoire mais est un mécanisme complémentaire au système de mémoire.

Ce qu'elle stocke : Tous les originaux des conversations historiques.

Emplacement de stockage : Local ~/.hermes/state.db.

Méthode de récupération : Recherche par mots-clés FTS5 + résumé LLM.

Méthode d'écriture : Automatique (chaque tour de conversation est automatiquement persisté dans SQLite).

session_search distingue deux modes :

Mode 1 : Requête vide → Retourne directement la liste des sessions récentes sans appeler LLM.

Mode 2 : Requête présente → Récupération FTS5 → Résumé LLM.

Il y a aussi un repli : si l'appel LLM de résumé échoue, il retourne directement un aperçu brut des 500 premiers caractères du texte original, garantissant qu'il y a toujours quelque chose même si le LLM est en panne.

La présence d'une requête est décidée par l'Agent. Après avoir lu l'intention de l'utilisateur, l'Agent juge s'il a besoin de « feuilleter l'historique » ou de « rechercher un sujet spécifique », puis décide s'il doit passer une requête. C'est le mode standard d'utilisation des outils — le comportement est guidé par la description du schéma, et l'Agent choisit de manière autonome la méthode d'appel.

Ce serait génial si la recherche de session prenait en charge la récupération vectorielle. OpenClaw le fait (moteur de recherche hybride : BM25 + récupération vectorielle), mais la granularité est au niveau des fichiers de journal, pas au niveau de la session, donc chacun a ses avantages et inconvénients.

Cinquièmement : Configurer web_search

La capacité de recherche web de l'agent doit être configurée. Hermes est très facile à configurer ; il vous suffit de dire à Hermes de vous aider.

Hermes prend en charge nativement : exa, Tavily, parallel, firecrawl.

Des exemples de configuration et d'utilisation sont les suivants :

Dites à Hermes : « Aide-moi à configurer exa. »

Point fort n°5 d'Hermes : Les amis attentifs peuvent voir qu'Hermes affiche clairement son processus d'exécution d'outil dans l'IM par défaut, ce qui est très convivial.

Sixièmement : Audit automatisé (Hooks)

L'agent Hermes dispose de deux systèmes d'extension complémentaires :

1. Gateway Hooks : Hooks déclenchés par des événements de passerelle.
2. Plugin System : Hooks de cycle de vie des plugins.

Concept central : Les Hooks gèrent les notifications d'événements, et les Plugins gèrent les extensions fonctionnelles — les deux se complètent.

8 hooks de cycle de vie sont disponibles :

Exemple de flux d'exécution :

1Création de session
2  → on_session_start
3
4Chaque tour de conversation :
5  → pre_llm_call          ← Le contexte peut être injecté
6  → Boucle d'outils :
7      → pre_api_request   ← Avant chaque appel API
8      → Appel API
9      → post_api_request  ← Après chaque appel API
10      → pre_tool_call     ← Avant chaque exécution d'outil
11      → Exécution d'outil
12      → post_tool_call    ← Après chaque exécution d'outil
13  → post_llm_call         ← Fin du tour
14  → on_session_end        ← run_conversation retourne

Expérience pratique : Faisons une expérience de configuration de hook de passerelle pour auditer les appels d'outils.

Dites directement à Hermes : « Crée un Hook d'audit de terminal : après chaque exécution d'outil de terminal, ajoute automatiquement le contenu de la commande, le résultat de l'exécution, l'horodatage et l'ID de session dans un fichier journal. »

Après autorisation, Hermes l'a écrit :

Maintenant, notre hook d'audit de commandes est développé et configuré. N'est-ce pas plus pratique que Lobster (OpenClaw) ?

Septièmement : Bac à sable

La commande d'exécution par défaut est locale. Si vous voulez améliorer la sécurité, vous devez utiliser un bac à sable. Hermes prend en charge le bac à sable, et nous choisissons Docker ici.

Pour pratiquer, ouvrons un agent séparé pour configurer le bac à sable Docker.

Exemple comme suit (bien sûr, vous pouvez laisser votre agent Hermes vous aider à le configurer avec l'invite : « Référez-vous aux commandes suivantes et aide-moi à configurer un profil supplémentaire, en utilisant Docker pour le bac à sable, et le modèle suit le profil principal ») :

1# Lier le Worker à votre Bot secondaire (Token B)
2hermes -p worker config set gateway.telegram.bot_token "TOKEN_B"
3hermes -p worker config set gateway.telegram.enabled true
4
5# Définir le Worker en mode bac à sable Docker
6hermes -p worker config set terminal.backend docker
7hermes -p worker config set terminal.docker_image python:3.11-slim
8
9# Le Worker peut utiliser un modèle moins cher
10hermes -p worker config set model.provider alibaba
11hermes -p worker config set model.model qwen3.5-plus

Hermes configure tout pour vous ; vous n'avez pas besoin de le faire vous-même, fournissez juste une clé de bot supplémentaire.

Test : J'ai dit au bot de travail rm -rf /. En regardant la capture d'écran, il a d'abord refusé, haha.

Je l'ai encouragé, et il a finalement confirmé l'exécution. Comme on le voit dans la capture d'écran, il a également dit que la protection système avait été déclenchée et que seuls certains répertoires avaient été supprimés.

L'agent principal résout le problème. Confirmé, pas de problème.

Nous vérifions ensuite docker ps sur la machine hôte. Vous pouvez voir que Docker a bien été démarré. Parfait~

Point fort n°6 d'Hermes : La configuration multi-profil (instance d'agent) est conviviale. Une phrase et Hermes s'en charge. Dans Lobster, je devais encore me connecter au backend pour ajuster.

Huitièmement : Multi-agent

Le multi-agent nécessite un article séparé. Voici juste un résumé de notre wiki. Différentes capacités multi-agent peuvent être déclenchées dans une même session. Bien sûr, il y a aussi le multi-agent complètement isolé, qui est le multi-profil mentionné ci-dessus.

Déclencher un sous-agent dans une conversation est très simple ; il suffit d'un mot. Exemple :

« S'il te plaît, crée trois sous-agents pour discuter des avantages et des inconvénients d'Hermes entre eux. »

Neuvièmement : Sauvegarde

Si vous décidez de passer à Hermes Agent, la sauvegarde est essentielle.

Trois couches de sauvegarde sont recommandées :

Couche 1 : Activer git local. Un peu plus loin, pousser vers GitHub. Il est suggéré de pousser vers un dépôt privé. .env ne doit pas être poussé (configurez .gitignore), utilisez la sauvegarde sur disque local.

Couche 2 : Sauvegarde vers d'autres répertoires sur le local (de préférence d'autres disques) + tâches planifiées.

Annexe, script clé :

1#!/bin/bash
2# Nom de la sauvegarde avec date/heure
3BACKUP_NAME="hermes_full_backup_$(date +%Y%m%d_%H%M%S)"
4BACKUP_DIR="/tmp/$BACKUP_NAME"
5DEST_DIR=~/hermes_backups
6
7# Créer les répertoires
8mkdir -p $BACKUP_DIR/hermes
9mkdir -p $DEST_DIR
10
11echo "📦 Emballage de la configuration principale..."
12cp ~/.hermes/config.yaml $BACKUP_DIR/hermes/
13cp ~/.hermes/.env $BACKUP_DIR/hermes/
14cp ~/.hermes/MEMORY.md $BACKUP_DIR/hermes/ 2>/dev/null
15
16echo "🧠 Emballage de la base de données et des sessions..."
17cp ~/.hermes/state.db $BACKUP_DIR/hermes/
18# Si les sessions sont volumineuses, vous pouvez ne sauvegarder que les fichiers récents ; ici nous sauvegardons tout
19cp -r ~/.hermes/sessions $BACKUP_DIR/hermes/ 2>/dev/null
20
21echo "🔧 Emballage des extensions et des audits..."
22cp -r ~/.hermes/plugins $BACKUP_DIR/hermes/ 2>/dev/null
23cp -r ~/.hermes/audit_logs $BACKUP_DIR/hermes/ 2>/dev/null
24cp -r ~/.hermes/skills $BACKUP_DIR/hermes/ 2>/dev/null
25cp -r ~/.hermes/cron $BACKUP_DIR/hermes/ 2>/dev/null
26
27echo "👥 Emballage de toutes les données de profil..."
28# Le profil contient toutes les configurations et bases de données pour les clones comme worker
29cp -r ~/.hermes/profiles $BACKUP_DIR/hermes/ 2>/dev/null
30
31echo "📦 Compression..."
32tar -czf $DEST_DIR/$BACKUP_NAME.tar.gz -C /tmp $BACKUP_NAME
33rm -rf $BACKUP_DIR
34
35echo ""
36echo "✅ Sauvegarde terminée !"
37echo "📍 Chemin : $DEST_DIR/$BACKUP_NAME.tar.gz"
38echo "📊 Taille : $(du -h $DEST_DIR/$BACKUP_NAME.tar.gz | cut -f1)"

Couche 3 : Sauvegarde distante : par exemple, disques ; git push vers distant ; autres serveurs ; ou stockage objet tiers, etc.

Dixièmement : Compétence

Rien de spécial à dire ici, installez simplement vos compétences couramment utilisées.

Hermes est très intelligent ; il examine les compétences. Il identifie nos tâches et résume et solidifie automatiquement le processus en une Compétence.

Condition de déclenchement : Dans config.yaml, nous voyons creation_nudge_interval par défaut à 15 (les versions plus anciennes peuvent être à 10).

Ce paramètre signifie que tous les 15 cycles d'outils, une révision de compétence en arrière-plan est déclenchée.

Processus de révision de compétence :

1Dériver un agent en arrière-plan, prendre un instantané complet de la conversation en cours, et se poser la question suivante :
2
3> « Dans la conversation précédente, y avait-il une expérience non triviale impliquant des essais et erreurs, des ajustements de direction, ou des attentes de l'utilisateur pour différentes approches ? »
4
5Ensuite trois résultats :
61. **Une compétence existante peut être mise à jour** → Appeler `skill_manage` pour mettre à jour la compétence existante avec la nouvelle expérience.
72. **Aucune mais mérite d'être créée** → Appeler `skill_manage` pour créer une nouvelle compétence et solidifier les méthodologies réutilisables.
83. **Rien à sauvegarder** → Sortir « Rien à sauvegarder. » et terminer.
9
10Tout le processus s'exécute dans un thread en arrière-plan, ne bloque pas la conversation utilisateur et ne modifie pas l'historique principal de la conversation. S'il y a une action, une ligne est imprimée dans le terminal.

Point fort n°7 d'Hermes : Convertir automatiquement les opérations précieuses en compétences permanentes est une fonctionnalité exceptionnelle. La grandeur n'a pas besoin de plus de mots~

Point fort n°8 d'Hermes : Peu importe comment vous quittez (normal/anormal/interrompu), les messages ne sont pas perdus. 20 points de déclenchement couvrent tous les chemins de sortie, écriture incrémentielle, et la division de session assure également que chaque enregistrement de session est complet et non répétitif.

En raison des limites d'espace, nous trouverons une occasion de discuter des sessions en détail plus tard.

Postface

Après quelques jours à expérimenter Hermes, j'ai ressenti beaucoup de ses points forts. L'expérience globale est très fluide. La stabilité est meilleure que celle d'OpenClaw, ce qui peut nous faire économiser 30 % du temps passé à réparer Lobster.

Lobster nécessite généralement des modèles SOTA étrangers ; sinon, il se casse facilement tout seul.

Avec Hermes, nous avons utilisé qwen 3.6 plus tout au long. De nombreuses opérations comme la configuration et les mises à niveau peuvent être effectuées simplement en discutant avec Hermes sans planter, ce qui est très rare.

Documents de référence :

1. Code source : https://github.com/NousResearch/hermes-agent
2. Wiki rédigé par Lan Shu : https://github.com/cclank/Hermes-Wiki
3. Documentation officielle : https://hermes-agent.nousresearch.com/docs/

Version du compte officiel : https://mp.weixin.qq.com/s/0SYL-HKbWGj3eToQPqnpBw

Cet article est purement tapé à la main basé sur une expérience pratique. La création n'est pas facile ; les amis sont invités à soutenir avec un triple appui~ 💗