Masterclass sur l'agent Hermes : Le cours complet, de zéro à l'exploitation autonome d'agents

Voici la traduction en français du texte fourni, en respectant toutes les consignes de formatage, de terminologie et de qualité de localisation.

La plupart des personnes qui découvrent Hermes Agent passent la première semaine à être perplexes.

Pas parce qu'Hermes est compliqué.

Mais parce que personne n'a encore écrit le guide complet qui vous emmène de zéro à un système d'agents autonomes pleinement opérationnel en une seule lecture.

Ce guide est ce chaînon manquant.

À la fin de ce cours intensif, vous aurez installé Hermes, configuré votre premier agent, construit votre première compétence, connecté votre premier serveur MCP, mis en place une mémoire persistante, automatisé votre premier workflow et déployé une opération multi-agents qui fonctionne sans vous.

Chaque section s'appuie sur la précédente. Lisez-les dans l'ordre la première fois. Revenez à des sections spécifiques lorsque vous avez besoin de vous y référer plus tard.

Section 1 : Ce qu'est réellement Hermes Agent

Avant d'installer quoi que ce soit, comprenez avec quoi vous construisez.

Hermes Agent est un framework open source d'agent IA autonome. Ce n'est pas un chatbot. Ce n'est pas une surcouche d'un outil existant. C'est une infrastructure pour construire des agents qui opèrent de manière persistante, se souviennent de tout entre les sessions, exécutent des workflows réutilisables et fonctionnent de manière autonome selon un planning.

Les quatre propriétés qui rendent Hermes différent de tout autre framework d'agent :

Mémoire persistante. La plupart des agents IA oublient tout lorsque vous fermez la session. Hermes se souvient. Chaque conversation, chaque tâche, chaque résultat, chaque décision est stocké dans une couche mémoire qui persiste indéfiniment. L'agent avec lequel vous interagissez aujourd'hui sait tout ce qui s'est passé dans toutes les sessions précédentes.

Système de compétences. Hermes exécute des fichiers de workflow réutilisables appelés compétences. Vous écrivez une compétence une fois sous forme de fichier Markdown décrivant ce que l'agent doit faire. Chaque exécution ultérieure appelle cette compétence sans reconstruire la logique. Votre opération devient plus rapide et plus cohérente à chaque compétence que vous ajoutez.

Automatisation planifiée. Hermes fonctionne selon un planning configurable sans que vous ayez à initier quoi que ce soit. Briefings de recherche matinaux. Traitement de contenu nocturne. Surveillance horaire des sources. Tout cela se déclenche automatiquement aux heures que vous configurez.

Intégration MCP. Hermes se connecte à des serveurs Model Context Protocol qui lui donnent accès à de véritables outils. Systèmes de fichiers. Bases de données. Recherche web. API. Services externes. Chaque connexion MCP transforme Hermes d'un modèle de langage en un agent qui agit sur le monde réel.

Ces quatre propriétés, combinées, produisent quelque chose de qualitativement différent de toute interaction IA individuelle.

Un agent Hermes n'est pas un outil que vous utilisez.

C'est un système qui opère.

Section 2 : Installation et configuration initiale

Prérequis :

Node.js version 18 ou supérieure. Git. Un terminal que vous savez utiliser.

Vérifiez votre version de Node.js :

node --version

Si vous devez installer ou mettre à jour Node.js, visitez nodejs.org et téléchargez la version LTS actuelle.

Installer Hermes :

git clone https://github.com/hermes-agent/hermes

cd hermes

npm install

Configurer votre environnement :

cp .env.example .env

Ouvrez le fichier .env et configurez votre fournisseur de modèle :

Configuration du modèle principal

MODEL_PROVIDER=anthropic

MODEL_NAME=claude-opus-4-5

ANTHROPIC_API_KEY=votre-clé-api-anthropic

Alternative : Utiliser DeepSeek pour un fonctionnement gratuit

MODEL_PROVIDER=deepseek

MODEL_NAME=deepseek-chat

DEEPSEEK_API_KEY=votre-clé-deepseek

Configuration mémoire

MEMORY_BACKEND=sqlite

MEMORY_PATH=./data/memory.db

Planificateur

ENABLE_SCHEDULER=true

SCHEDULER_TIMEZONE=America/New_York

Journalisation

LOG_LEVEL=info

LOG_PATH=./logs/hermes.log

Démarrer Hermes :

npm run start

Vous devriez voir une sortie confirmant qu'Hermes est en cours d'exécution :

[Hermes] Backend mémoire : SQLite initialisé

[Hermes] Répertoire de compétences : ./skills chargé

[Hermes] Planificateur : activé

[Hermes] Agent prêt. En attente d'instructions.

Hermes est maintenant en cours d'exécution avec une mémoire persistante et le planificateur actif.

Vérifier l'installation :

Tapez votre premier message :

Bonjour. Que sais-tu de toi-même ?

Hermes devrait répondre en décrivant sa configuration, son état mémoire et les compétences disponibles.

Section 3 : Comprendre l'architecture des fichiers

Avant de construire quoi que ce soit, comprenez où tout se trouve.

hermes/

skills/

[votre-nom-de-compétence].md

data/

memory.db

processed/

outputs/

logs/

hermes.log

config/

sources.json

schedule.json

CLAUDE.md

.env

package.json

skills/ est l'endroit où réside chaque workflow que vous construisez. Chaque compétence est un fichier Markdown. Hermes lit ces fichiers et exécute les workflows qu'ils décrivent.

data/ est l'endroit où Hermes stocke tout ce qu'il traite. memory.db est la base de données SQLite qui alimente la mémoire persistante. processed/ contient les éléments qui ont été traités. outputs/ contient le contenu généré.

logs/ contient les journaux d'opération. Consultez hermes.log lorsque quelque chose ne fonctionne pas comme prévu.

config/ contient vos fichiers de configuration. sources.json définit vos sources de contenu. schedule.json définit quand les workflows automatisés s'exécutent.

CLAUDE.md est le fichier le plus important de toute l'installation. Il indique à Hermes tout sur qui vous êtes, ce que vous faites et comment vous voulez qu'il fonctionne. Nous le construirons dans la Section 4.

Section 4 : Rédiger votre CLAUDE.md

Le CLAUDE.md est la constitution opérationnelle de votre agent Hermes.

Chaque compétence le lit avant de s'exécuter. Chaque workflow automatisé l'utilise pour le contexte. Chaque résultat est façonné par lui.

Un CLAUDE.md mal rédigé produit des résultats génériques.

Un CLAUDE.md rédigé avec précision produit des résultats qui semblent avoir été créés par quelqu'un qui connaît votre activité de fond en comble.

Voici le modèle complet :

Hermes Agent — CLAUDE.md

Identité

Nom : [VOTRE NOM OU MARQUE]

Rôle : [CE QUE VOUS FAITES]

Plateforme principale : [OÙ VOUS PUBLIEZ]

Public : [QUI VOUS SERVEZ]

Contenu et axes de travail

Sujets principaux : [LISTEZ VOS SUJETS PRINCIPAUX]

Formats de contenu : [CE QUE VOUS CRÉEZ]

Voix et ton : [COMMENT VOUS COMMUNIQUEZ]

Ce que vous ne faites jamais : [CHOSES SPÉCIFIQUES À ÉVITER]

Projets en cours

[PROJET 1] : [DESCRIPTION EN UNE PHRASE]

Statut : [ACTIF/EN ATTENTE/TERMINÉ]

Prochaine action : [PROCHAINE ÉTAPE SPÉCIFIQUE]

[PROJET 2] : [DESCRIPTION EN UNE PHRASE]

Statut : [ACTIF/EN ATTENTE/TERMINÉ]

Prochaine action : [PROCHAINE ÉTAPE SPÉCIFIQUE]

Priorités actuelles

1. [LA CHOSE LA PLUS IMPORTANTE EN CE MOMENT]
2. [LA DEUXIÈME PLUS IMPORTANTE]
3. [LA TROISIÈME PLUS IMPORTANTE]

Standards de contenu

Un excellent résultat : [DESCRIPTION SPÉCIFIQUE]

Un résultat acceptable : [SEUIL MINIMUM]

Un résultat rejeté : [CE QUI ÉCHOUE]

Sources de confiance

[LISTEZ LES PUBLICATIONS, CHAÎNES, PERSONNES SPÉCIFIQUES]

Ce que je ne veux spécifiquement pas

[LISTEZ LES SUJETS, FORMATS OU APPROCHES À ÉVITER]

Règles de mémoire

• Stocker chaque décision importante avec son raisonnement
• Suivre tout le contenu publié avec des notes de performance
• Se souvenir des évaluations de qualité des sources
• Ne jamais répéter le contenu de la même source dans les 72 heures

Règles de sortie

• Sauvegarder tout le contenu généré dans data/outputs/
• Horodater chaque fichier : AAAA-MM-JJ-[type]-[sujet].md
• Journaliser toutes les opérations dans logs/hermes.log
• Signaler tout ce qui nécessite une relecture humaine avant publication

Calendrier de mise à jour

Réviser et mettre à jour ce fichier : [VOTRE CALENDRIER]

Prenez 30 minutes pour remplir complètement ce document avant de construire des compétences. Tout ce qui suit dépend de la qualité de ce document.

Section 5 : Construire votre première compétence

Une compétence est un fichier Markdown en texte brut qui décrit un workflow qu'Hermes exécute.

Le format de la compétence comporte quatre sections obligatoires :

nom-de-la-compétence

Objectif

[Une phrase décrivant ce que fait cette compétence]

Déclencheur

[Comment l'invoquer — manuellement ou selon un planning]

Processus

[Instructions étape par étape pour ce qu'Hermes fait]

Résultat

[Ce que la compétence produit et où elle le sauvegarde]

Construisons votre première vraie compétence : un briefing matinal qui lit vos sources configurées et fournit un résumé structuré.

Créez skills/morning-briefing.md :

morning-briefing

Objectif

Générer un briefing de renseignement matinal structuré

à partir de toutes les sources configurées et le sauvegarder

dans le dossier outputs.

Déclencheur

Planifié quotidiennement à 6h00.

Manuel : "Lancer le briefing matinal" ou "Générer mon briefing"

Processus

1. Lire CLAUDE.md pour le contexte complet sur qui je suis et quels sujets m'importent.

1. Lire config/sources.json pour toutes les sources configurées.

1. Pour chaque source dans ma liste de sujets principaux : Rechercher les développements significatifs des dernières 24 heures en utilisant la recherche web.

Filtrer les résultats en utilisant ces critères :

INCLURE : Nouvelles annonces, mises à jour importantes,

résultats de recherche, mouvements stratégiques des acteurs clés

EXCLURE : Contenu recyclé, articles d'opinion sans

nouvelles informations, tout ce que je classerais comme bruit

en fonction de mes préférences dans CLAUDE.md

1. Vérifier la mémoire pour tout élément pertinent des sessions précédentes qui se connecte aux actualités du jour.

1. Générer le briefing dans ce format :

Briefing Matinal — [DATE]

L'ESSENTIEL

[Développement le plus important du jour et pourquoi il

est spécifiquement important pour mon travail]

CE QU'IL S'EST PASSÉ

[3 à 7 éléments significatifs, chacun en 2-3 phrases]

À SURVEILLER

[1-2 situations en développement qui méritent une attention]

DE LA MÉMOIRE

[Toute connexion pertinente avec quelque chose stocké

lors de sessions précédentes]

FOCUS DU JOUR

[Priorité unique recommandée basée sur le briefing]

1. Sauvegarder le briefing dans : data/outputs/[DATE]-morning-briefing.md

1. Stocker le résumé en mémoire avec le tag : daily-brief

Résultat

Fichier de briefing structuré dans le dossier outputs.

Entrée mémoire taguée : daily-brief

Entrée de journal dans hermes.log

Testez votre première compétence :

Lancer le briefing matinal

Regardez Hermes exécuter chaque étape, rechercher des informations et générer votre premier briefing automatisé.

Section 6 : Le système de mémoire

La mémoire est ce qui transforme Hermes d'un outil compétent en un système à effet cumulatif.

Comprendre comment fonctionne la mémoire vous permet de concevoir des compétences qui deviennent progressivement plus intelligentes au fil du temps.

Comment Hermes stocke la mémoire :

Chaque opération significative crée une entrée mémoire dans la base de données SQLite. Chaque entrée a :

• Contenu : ce qui a été stocké
• Tags : catégories pour la récupération
• Horodatage : quand elle a été créée
• Source : quelle compétence l'a créée
• Score de pertinence : mis à jour en fonction de la fréquence à laquelle elle est récupérée

Comment Hermes récupère la mémoire :

Lorsqu'une compétence s'exécute, Hermes recherche automatiquement dans la mémoire le contexte pertinent avant d'exécuter. La recherche utilise la similarité sémantique, donc les concepts connexes remontent même lorsque les mots-clés exacts ne correspondent pas.

Concevoir des compétences pour la mémoire :

Incluez des instructions de mémoire explicites dans chaque compétence :

Instructions mémoire

STOCKER après achèvement :

• Résultats clés tagués : [tags-pertinents]
• Décisions prises taguées : décision
• Résultats produits tagués : résultat

RÉCUPÉRER avant de commencer :

• Exécutions précédentes de cette compétence
• Toutes les entrées taguées : [tags-pertinents]
• Décisions qui affectent ce workflow

Opérations mémoire manuelles :

Stocke ceci en mémoire : [information] — tagge-le comme [tag]

Que sais-tu de [sujet] ?

Montre-moi toutes les entrées mémoire des 7 derniers jours

Quelles décisions ont été stockées ?

L'effet cumulatif de la mémoire :

Un agent Hermes avec une semaine de mémoire est utile.

Un agent Hermes avec trois mois de mémoire est une catégorie d'outil différente.

Après trois mois d'utilisation quotidienne, Hermes a lu des centaines de sources, traité des milliers de contenus, suivi des dizaines de décisions et construit une image détaillée de ce qui fonctionne et de ce qui ne fonctionne pas dans votre opération spécifique.

Chaque nouvelle tâche bénéficie de ce contexte accumulé.

Section 7 : Connecter les serveurs MCP

Les serveurs MCP transforment Hermes d'un agent qui raisonne sur le monde en un agent qui agit sur lui.

Chaque connexion MCP donne à Hermes accès à un véritable outil. Systèmes de fichiers. Recherche web. Bases de données. API. Services externes.

Installer les serveurs MCP de base :

Filesystem MCP — lire et écrire des fichiers locaux

npm install -g @modelcontextprotocol/server-filesystem

Recherche web — Brave Search en temps réel

npm install -g @modelcontextprotocol/server-brave-search

GitHub — accès aux dépôts

npm install -g @modelcontextprotocol/server-github

Puppeteer — automatisation du navigateur

npm install -g @modelcontextprotocol/server-puppeteer

Configurer les connexions MCP dans votre .env :

Filesystem

MCP_FILESYSTEM_PATH=/chemin/vers/votre/répertoire/de/travail

Brave Search

MCP_BRAVE_API_KEY=votre-clé-api-brave-search

GitHub

MCP_GITHUB_TOKEN=votre-token-daccès-personnel-github

Puppeteer

MCP_PUPPETEER_HEADLESS=true

Le Filesystem MCP :

La connexion la plus immédiatement utile. Donne à Hermes un accès direct en lecture et écriture à vos fichiers locaux.

Une fois connecté, Hermes peut :

Lire les fichiers que vous spécifiez dans les instructions de compétence. Écrire les résultats directement dans des dossiers sur votre système. Mettre à jour les fichiers en fonction de nouvelles informations. Surveiller les dossiers pour du nouveau contenu.

Compétences qui utilisent le Filesystem MCP :

Processus

1. Lire le fichier à [CHEMIN] pour le contexte
2. Traiter le contenu
3. Écrire le résultat dans [CHEMIN DE SORTIE]
4. Mettre à jour le fichier d'index à [CHEMIN D'INDEX]

Le Brave Search MCP :

Donne à Hermes accès à la recherche web en temps réel. Sans cela, Hermes ne peut raisonner que sur des informations jusqu'à sa date de coupure de connaissances. Avec lui, Hermes recherche sur le web en direct pour des informations actuelles.

Chaque compétence de recherche, de surveillance et de briefing bénéficie de Brave Search.

Obtenez votre clé API Brave Search gratuite sur brave.com/search/api. Le niveau gratuit permet 2 000 requêtes par mois.

Le GitHub MCP :

Donne à Hermes accès aux dépôts GitHub. Il peut lire du code, vérifier les dépôts tendance, surveiller les dépôts que vous suivez et suivre les versions.

Utile pour : le contenu sur les outils de développement, la surveillance open source, la recherche technique, l'analyse de dépôts.

Vérifier les connexions MCP :

Quels serveurs MCP sont actuellement connectés ?

Liste tous les outils disponibles des serveurs connectés.

Hermes devrait lister chaque serveur connecté et les outils que chacun fournit.

Section 8 : Le système de planification

Le planificateur transforme Hermes d'un outil que vous utilisez en un système qui opère.

Sans le planificateur : Hermes fait ce que vous demandez quand vous le demandez.

Avec le planificateur : Hermes fonctionne en continu, que vous soyez impliqué ou non.

Configurer votre planning :

Créez config/schedule.json :

{

"schedules": [

{

"skill": "morning-briefing",

"cron": "0 6 \ \ *",

"description": "Briefing matinal quotidien à 6h00"

},

{

"skill": "source-monitor",

"cron": "0 \/2 \ \ \",

"description": "Vérifier les sources toutes les 2 heures"

},

{

"skill": "content-processor",

"cron": "0 20 \ \ *",

"description": "Traiter le contenu capturé à 20h00"

},

{

"skill": "weekly-review",

"cron": "0 19 \ \ 0",

"description": "Revue hebdomadaire tous les dimanches à 19h00"

},

{

"skill": "memory-consolidation",

"cron": "0 23 \ \ *",

"description": "Consolider les entrées mémoire à 23h00"

}

]

}

Référence des expressions cron :

0 6 \ \ * → 6h00 tous les jours

0 \/2 \ \ \ → Toutes les 2 heures

0 20 \ \ 1-5 → 20h00 du lundi au vendredi

0 19 \ \ 0 → 19h00 tous les dimanches

0 23 \ \ * → 23h00 tous les jours

Les cinq workflows planifiés dont toute opération Hermes a besoin :

Briefing matinal : 6h00 tous les jours. Lit les sources. Génère un briefing de renseignement. Définit le focus du jour.

Surveillance des sources : Toutes les 2 heures. Vérifie les sources configurées pour du nouveau contenu. Ajoute à la file d'attente de traitement.

Traitement du contenu : 20h00 tous les jours. Traite tout ce qui a été capturé pendant la journée. Génère des résultats. Met à jour la mémoire.

Revue hebdomadaire : Dimanche 19h00. Synthétise l'activité de la semaine. Identifie les tendances. Génère des insights.

Consolidation de la mémoire : 23h00 tous les jours. Passe en revue les nouvelles entrées mémoire. Supprime les doublons. Met à jour les scores de pertinence.

Surveiller l'exécution planifiée :

Montre-moi les opérations planifiées pour aujourd'hui

Qu'est-ce qui a été exécuté au cours des dernières 24 heures ?

Montre-moi le journal d'exécution

Section 9 : Construire une opération de contenu complète

Cette section vous guide dans la construction d'une opération de contenu automatisée complète avec Hermes. À la fin, vous aurez un système qui surveille les sources, identifie les opportunités de contenu viral, génère des brouillons et gère une file d'attente de publication automatiquement.

Étape 1 : Configurer vos sources

Créez config/sources.json :

{

"sources": [

{

"name": "Blog Anthropic",

"type": "rss",

"url": "https://anthropic.com/news/rss",

"priority": "critique",

"check_interval": "1h"

},

{

"name": "GitHub Trending IA",

"type": "web",

"url": "https://github.com/trending/python?since=daily",

"priority": "élevée",

"check_interval": "4h"

},

{

"name": "HackerNews IA",

"type": "web",

"url": "https://news.ycombinator.com",

"priority": "moyenne",

"check_interval": "2h"

}

]

}

Étape 2 : Construire l'identificateur d'opportunités de contenu

Créez skills/content-opportunity.md :

content-opportunity

Objectif

Analyser toutes les sources pour trouver des opportunités de contenu

qui méritent d'être créées et les ajouter à la file d'attente de contenu.

Déclencheur

S'exécute après que source-monitor a détecté du nouveau contenu.

Manuel : "Trouver des opportunités de contenu"

Processus

1. Lire CLAUDE.md pour mes piliers de contenu et mon public.

1. Lire tous les éléments marqués comme nouveaux par source-monitor dans la mémoire taguée : source-monitor-new.

1. Pour chaque nouvel élément, évaluer :

SCORE DE POTENTIEL VIRAL (1-10) :

• Est-ce que cela intéresse mon public spécifique ?
• S'agit-il d'informations réellement nouvelles ou d'un recyclage ?
• Cela se connecte-t-il à l'un de mes piliers de contenu actuels ?
• Y a-t-il un angle unique que je peux adopter et que d'autres n'ont pas ?

Seuls les éléments obtenant un score de 7 ou plus sont qualifiés comme opportunités.

1. Pour chaque opportunité qualifiée, créer une entrée dans data/outputs/content-queue.md avec :
2. Source et lien
3. Pourquoi c'est une opportunité
4. Angle de contenu suggéré
5. Format suggéré (tweet/fil/article/vidéo)
6. Priorité : urgente/élevée/moyenne

1. Stocker toutes les opportunités en mémoire taguées : content-queue

Résultat

Fichier content-queue.md mis à jour.

Entrées mémoire taguées : content-queue

Étape 3 : Construire le générateur de brouillons

Créez skills/draft-generator.md :

draft-generator

Objectif

Générer des brouillons de contenu pour les éléments de la

file d'attente de contenu en fonction de leur priorité.

Déclencheur

S'exécute quotidiennement à 14h00.

Manuel : "Générer des brouillons" ou "Rédiger les 3 premiers éléments"

Processus

1. Lire CLAUDE.md pour ma voix, mon ton et mes règles de contenu.

1. Lire data/outputs/content-queue.md pour les éléments en attente.

1. Sélectionner les 3 premiers éléments par score de priorité.

1. Pour chaque élément sélectionné :

a. Rechercher le sujet en utilisant la recherche web pour s'assurer

que les informations sont actuelles et exactes

b. Vérifier la mémoire pour toute couverture précédente de

ce sujet afin d'éviter les répétitions

c. Générer le brouillon dans le format spécifié :

Pour les TWEETS :

Suivre le format cyrilXBT :

• Accroche de déclaration en MAJUSCULES
• Lignes courtes et percutantes
• Chaque phrase sur sa propre ligne
• Bookmark this + Appel à l'action Suis-moi à la fin

Pour les FILS :

• Tweet d'accroche
• 5 à 8 tweets de corps avec des détails spécifiques
• Appel à l'action de clôture

Pour les ARTICLES :

• Paragraphe d'accroche fort
• Énoncé du problème
• Présentation de la solution
• Étapes actionnables
• Appel à l'action pour suivre

1. Sauvegarder chaque brouillon dans : data/outputs/drafts/[DATE]-[FORMAT]-[SUJET].md

1. Mettre à jour content-queue.md en marquant les éléments comme rédigés.

1. Stocker les résumés des brouillons en mémoire tagués : draft-generated

Résultat

Fichiers de brouillon dans data/outputs/drafts/

Fichier content-queue.md mis à jour

Entrées mémoire taguées : draft-generated

Étape 4 : Construire le suivi de performance

Créez skills/performance-tracker.md :

performance-tracker

Objectif

Suivre la performance du contenu et utiliser les données pour

améliorer les futures décisions de contenu.

Déclencheur

Manuel : "Enregistrer la performance pour [contenu] — [métriques]"

La revue hebdomadaire lit tous les journaux de performance.

Processus

1. Lorsque déclenché avec des données de performance :
2. Stocker les métriques en mémoire avec la référence au contenu
3. Tagger : performance-log

1. Identifier les tendances :
2. Quels sujets ont le mieux performé cette semaine ?
3. Quels formats ont eu le plus d'engagement ?
4. Quelles sources ont produit le plus de contenu viral ?

1. Mettre à jour les priorités de contenu dans CLAUDE.md en fonction des données de performance si les tendances sont claires.

1. Générer un rapport de performance hebdomadaire le dimanche.

Résultat

Entrées mémoire taguées : performance-log

Rapport de performance hebdomadaire dans le dossier outputs

Section 10 : Opérations multi-agents

Un seul agent Hermes est puissant. Un Hermes multi-agents est une catégorie de capacité différente.

L'opération multi-agents signifie plusieurs instances Hermes spécialisées, chacune gérant un domaine de votre opération, partageant la mémoire et coordonnant les résultats.

L'opération de contenu à quatre agents :

Agent de Recherche : Surveille les sources, identifie les opportunités, mène des recherches approfondies. Lit uniquement. Ne crée jamais.

Agent de Production : Prend les résultats de la recherche et génère des brouillons de contenu. Crée uniquement. Ne publie jamais.

Agent Qualité : Examine les résultats de la production par rapport aux normes. Approuve ou renvoie pour révision. Ne crée ni ne publie jamais.

Agent de Distribution : Prend les résultats approuvés et gère le calendrier de publication. Publie uniquement. Ne crée jamais.

Configurer la configuration multi-agents :

Créez des fichiers CLAUDE.md séparés pour chaque agent :

hermes-recherche/

CLAUDE.md ← Constitution de l'agent de recherche

skills/ ← Compétences de recherche uniquement

hermes-production/

CLAUDE.md ← Constitution de l'agent de production

skills/ ← Compétences de production uniquement

hermes-qualite/

CLAUDE.md ← Constitution de l'agent qualité

skills/ ← Compétences qualité uniquement

hermes-distribution/

CLAUDE.md ← Constitution de l'agent de distribution

skills/ ← Compétences de distribution uniquement

La couche mémoire partagée :

Configurez les quatre agents pour pointer vers la même base de données SQLite :

MEMORY_PATH=/shared/hermes-memory.db

Cela signifie que chaque agent lit les résultats de tous les autres agents. Les résultats de la recherche sont visibles par la production. Les résultats de la production sont visibles par la qualité. Les approbations qualité sont visibles par la distribution.

Le protocole de transfert :

Chaque agent signale son état de préparation pour le transfert via des tags mémoire :

L'agent de recherche termine le travail → stocke le résultat tagué : ready-for-production

L'agent de production récupère les éléments tagués → stocke le résultat tagué : ready-for-quality

L'agent qualité approuve → stocke le résultat tagué : ready-for-distribution

L'agent de distribution publie → stocke le résultat tagué : published

La compétence orchestrateur :

Créez une compétence orchestrateur maître qui surveille l'ensemble du pipeline :

pipeline-orchestrator

Objectif

Surveiller les quatre agents et assurer des

transferts fluides entre les étapes du pipeline.

Déclencheur

S'exécute toutes les 30 minutes.

Processus

1. Vérifier les éléments tagués : ready-for-production Si trouvé : alerter l'agent de production

1. Vérifier les éléments tagués : ready-for-quality Si trouvé : alerter l'agent qualité

1. Vérifier les éléments tagués : ready-for-distribution Si trouvé : alerter l'agent de distribution

1. Vérifier les éléments dans n'importe quelle étape depuis plus de 4 heures Si trouvé : marquer comme bloqué et alerter pour révision

1. Générer un rapport d'état du pipeline toutes les 4 heures

Résultat

État du pipeline en mémoire tagué : pipeline-status

Alertes pour les éléments bloqués

Journal d'opération horaire

Section 11 : Modèles de compétences avancés

À mesure que votre opération Hermes mûrit, vous rencontrerez des situations que le format de compétence de base ne couvre pas. Ces modèles avancés gèrent les scénarios complexes les plus courants.

Modèle 1 : Exécution conditionnelle

Compétences qui empruntent des chemins différents en fonction de conditions :

Processus

1. Vérifier la condition : [QUOI VÉRIFIER]

1. SI [CONDITION A] : Exécuter le chemin A : [ÉTAPES POUR LE CHEMIN A]

SI [CONDITION B] :

Exécuter le chemin B :

[ÉTAPES POUR LE CHEMIN B]

SI AUCUNE :

Signaler pour révision humaine et journaliser le cas ambigu.

Modèle 2 : Logique de nouvelle tentative

Compétences qui doivent réessayer en cas d'échec :

Processus

Pour chaque élément, tenter ce qui suit jusqu'à 3 fois :

1. Essayer : [APPROCHE PRINCIPALE] Si réussi : passer au résultat Si échoué : journaliser l'erreur et essayer l'alternative

1. Alternative : [APPROCHE DE SECOURS] Si réussi : passer au résultat avec une note indiquant que l'alternative a été utilisée Si échoué : marquer comme échoué et signaler pour révision

Ne jamais procéder avec un résultat incomplet ou incertain.

Modèle 3 : Passerelles qualité

Compétences qui appliquent des contrôles de qualité avant de produire un résultat :

Processus

1. Générer le résultat préliminaire

1. Vérifier par rapport aux critères de qualité :

• [ ] Le résultat répond-il aux normes de contenu de CLAUDE.md ?
• [ ] Toutes les sources sont-elles citées ?
• [ ] Le ton correspond-il à la voix spécifiée ?
• [ ] Y a-t-il des erreurs factuelles ?
• [ ] Le résultat est-il original par rapport aux entrées mémoire récentes ?

1. SI TOUS les critères sont remplis : Procéder à la sortie finale

SI UN CRITÈRE ÉCHOUE : Réviser et régénérer, puis répéter la vérification

SI APRÈS 3 TENTATIVES : Marquer pour révision humaine

Résultat

Résultat vérifié par qualité ou élément marqué pour révision humaine

Modèle 4 : Traitement par lots

Compétences qui traitent plusieurs éléments de la même manière :

Objectif

Traiter tous les éléments non traités dans la file d'attente.

Processus

1. Lire tous les éléments de [SOURCE] qui répondent aux critères : [CRITÈRES]

1. Pour CHAQUE élément de la liste :

a. [ÉTAPE DE TRAITEMENT]

b. [ÉTAPE DE TRANSFORMATION]

c. [ÉTAPE DE SORTIE]

d. Marquer comme traité dans la source

1. Une fois tous les éléments traités :

a. Générer le résumé du lot

b. Stocker le résumé en mémoire tagué : batch-summary

c. Journaliser les métriques de traitement

Résultat

Tous les éléments éligibles traités. Résumé du lot en mémoire.

Modèle 5 : Boucle de rétroaction

Compétences qui s'améliorent avec chaque exécution :

Objectif

Améliorer la qualité des résultats en apprenant des

exécutions précédentes.

Processus

1. Avant l'exécution : Récupérer les 5 dernières exécutions de cette compétence depuis la mémoire

1. Analyser les modèles dans les exécutions précédentes :

• Quels ajustements ont été apportés ?
• Quels résultats ont été les plus réussis ?
• Quels résultats ont nécessité une révision ?

1. Appliquer les apprentissages à l'exécution actuelle

1. Après l'exécution : Stocker les métriques de performance et les notes

1. Mettre à jour les instructions de la compétence si des améliorations claires sont identifiées

Résultat

Amélioration continue de la qualité des résultats

Section 12 : Dépannage et opérations

Même avec une configuration parfaite, des problèmes surviennent. Cette section couvre ce qui se casse le plus souvent et comment le réparer.

Problème : Hermes ne répond pas

Vérifier le journal :

Solutions courantes :

1. Vérifier que Node.js est en cours d'exécution : ps aux | grep node

1. Vérifier que le fichier .env est correctement formaté

1. Vérifier que la clé API est valide et active

1. Redémarrer Hermes : npm run start

Problème : La mémoire ne persiste pas

Vérifier que MEMORY_BACKEND=sqlite dans .env

Vérifier que le chemin MEMORY_PATH existe et est accessible en écriture

Vérifier que le fichier memory.db existe :

ls -la data/memory.db

Si manquant, Hermes le recréera automatiquement au prochain démarrage

Problème : Les compétences planifiées ne s'exécutent pas

Vérifier que ENABLE_SCHEDULER=true dans .env

Vérifier que config/schedule.json est valide JSON :

Vérifier que les noms de compétences dans schedule.json correspondent exactement aux noms de fichiers dans skills/

Vérifier le fuseau horaire : SCHEDULER_TIMEZONE doit correspondre à votre fuseau local

Problème : Les connexions MCP échouent

Vérifier que les packages MCP sont installés :

Vérifier que les clés API MCP sont valides

Tester chaque connexion MCP individuellement :

Quels outils le serveur filesystem me donne-t-il ?

Problème : Résultats de mauvaise qualité

La cause la plus fréquente est un CLAUDE.md faible.

Revoir la Section 4 et s'assurer que chaque section est complètement remplie avec des détails spécifiques à votre opération.

Vérifier que les compétences incluent des instructions de processus explicites.

Vérifier que les connexions MCP sont actives et fonctionnent.

Opérations de maintenance de routine :

Quotidiennement : Vérifier hermes.log pour les erreurs. Vérifier que les tâches planifiées se sont exécutées.

Hebdomadairement : Revoir et mettre à jour CLAUDE.md. Consolider les entrées mémoire. Vérifier les métriques de performance.

Mensuellement : Mettre à jour les listes de sources. Réviser les modèles de compétences pour les améliorations. Sauvegarder le fichier memory.db.

Section 13 : Prochaines étapes et ressources

Vous avez maintenant un système Hermes Agent entièrement opérationnel avec mémoire persistante, workflows automatisés, connexions MCP et opération multi-agents.

Ce qui vient ensuite dépend entièrement de ce que vous construisez dessus.

Extensions immédiates :

• Connecter des API supplémentaires via MCP
• Construire des compétences de surveillance personnalisées pour votre secteur
• Mettre en place des pipelines de traitement de données
• Ajouter des capacités de génération de rapports automatisés
• Intégrer avec vos outils existants

Où aller pour de l'aide :

Dépôt GitHub : github.com/hermes-agent/hermes

Documentation : hermes-agent.dev/docs

Discord communautaire : discord.gg/hermes-agent

Le principe directeur :

Hermes Agent est un système qui opère, pas un outil que vous utilisez.

Plus vous investissez dans la configuration initiale — CLAUDE.md, compétences, mémoire, sources — plus le système devient précieux au fil du temps.

Chaque compétence que vous écrivez rend la suivante plus rapide.

Chaque jour de mémoire rend chaque décision plus intelligente.

Chaque connexion MCP étend ce que le système peut faire.

Commencez avec la Section 1. Installez Hermes. Écrivez votre CLAUDE.md. Construisez votre première compétence. Laissez le système s'exécuter pendant une semaine.

Revenez dans sept jours et voyez ce qu'il a construit pour vous.

Compétences qui imposent des normes avant de produire une sortie :

Contrôle Qualité

Avant d'enregistrer une sortie, évaluez-la selon ces critères :

Critères de RÉUSSITE (tous doivent être vrais) :

• [CRITÈRE 1]
• [CRITÈRE 2]
• [CRITÈRE 3]

Si RÉUSSITE : enregistrer la sortie et journaliser le succès

Si ÉCHEC : identifier le(s) critère(s) défaillant(s), tenter une

révision, réévaluer. Maximum 2 tentatives de révision.

Si toujours en échec après 2 tentatives : enregistrer dans le dossier

review-needed/ avec les notes d'échec.

Modèle 4 : Exécution Informée par la Mémoire

Compétences qui deviennent plus intelligentes à chaque exécution :

Processus Informé par la Mémoire

Avant d'exécuter, récupérez :

• Toutes les exécutions précédentes de cette compétence depuis la mémoire
• Les données de performance étiquetées : [balise-pertinente]
• Toutes les notes de modèles stockées lors des exécutions précédentes

Utilisez le contexte récupéré pour :

• Éviter les approches qui ont échoué auparavant
• Prioriser les approches qui ont réussi auparavant
• Appliquer les informations sur les modèles à l'exécution actuelle

Après l'exécution, stockez :

• L'approche utilisée
• Si elle a réussi
• Tout nouveau modèle observé
• Étiqueté : [nom-compétence]-apprentissage

Section 12 : Résolution des Problèmes Courants

Chaque opération Hermès rencontre des problèmes au cours des premières semaines. Voici les problèmes les plus courants et comment les résoudre.

Problème : Hermès n'exécute pas les compétences planifiées

Vérifiez que le planificateur est activé dans votre .env :

ENABLE_SCHEDULER=true

Vérifiez que vos expressions cron sont valides en utilisant crontab.guru.

Consultez le fichier hermes.log pour les erreurs du planificateur :

tail -f logs/hermes.log

Problème : La mémoire ne persiste pas entre les sessions

Vérifiez que le chemin de la base de données mémoire est correct :

MEMORY_PATH=./data/memory.db

Vérifiez les permissions des fichiers sur le répertoire data :

ls -la data/

Le processus Hermès a besoin d'un accès en écriture à ce répertoire.

Problème : Les serveurs MCP ne se connectent pas

Vérifiez que le serveur MCP est installé globalement :

which npx

npx @modelcontextprotocol/server-filesystem --help

Vérifiez que vos clés API sont correctement définies dans .env sans espaces de fin.

Redémarrez Hermès après avoir modifié la configuration MCP.

Problème : Les sorties des compétences sont de faible qualité

La cause la plus fréquente est un CLAUDE.md vague. Revenez à la Section 4 et ajoutez des détails plus spécifiques à chaque section.

Vérifiez également que la section Processus de la compétence est suffisamment spécifique. Des instructions vagues produisent des sorties vagues.

Problème : Hermès utilise des informations obsolètes

Vérifiez que le MCP Brave Search est connecté :

Quels serveurs MCP sont connectés ?

Si Brave Search n'est pas listé, vérifiez votre clé API et réinstallez le serveur MCP.

Problème : Les compétences s'exécutent mais n'enregistrent pas les sorties

Vérifiez que le MCP Filesystem est connecté et pointe vers le bon chemin.

Vérifiez que les chemins de sortie dans vos fichiers de compétences sont relatifs au répertoire de travail dans lequel Hermès s'exécute.

Section 13 : Mesurer et Améliorer Votre Opération

Une opération Hermès qui ne s'améliore pas avec le temps n'utilise pas correctement son système de mémoire.

La compétence de révision hebdomadaire :

Créez skills/weekly-review.md :

weekly-review

Objectif

Synthétiser le fonctionnement de la semaine et identifier

les améliorations pour la semaine suivante.

Déclencheur

Tous les dimanches à 19h.

Manuel : "Lancer la révision hebdomadaire"

Processus

1. Lire toutes les entrées mémoire des 7 derniers jours.

1. Analyser les performances des compétences :
2. Quelles compétences se sont exécutées sans problème ?
3. Quelles compétences ont rencontré des erreurs ?
4. Quelles compétences ont produit les meilleures sorties ?
5. Quelles compétences nécessitent une amélioration ?

1. Analyser les performances du contenu (si journalisé) :
2. Quel contenu a le mieux performé ?
3. Quels modèles apparaissent chez les plus performants ?
4. Quels sujets devraient être prioritaires la semaine prochaine ?

1. Analyser la qualité de la mémoire :
2. Les entrées mémoire sont-elles créées correctement ?
3. Les résultats de récupération sont-ils pertinents lors de l'exécution des compétences ?
4. Y a-t-il des lacunes dans ce qui est stocké ?

1. Générer des recommandations d'amélioration :
2. Une compétence à améliorer cette semaine
3. Une nouvelle compétence à construire cette semaine
4. Un processus à rationaliser
5. Un sujet à prioriser dans le contenu

1. Mettre à jour CLAUDE.md avec les améliorations confirmées.

Sortie

Rapport de révision hebdomadaire dans data/outputs/

Mises à jour de CLAUDE.md si des améliorations sont identifiées

Entrée mémoire étiquetée : weekly-review

Les indicateurs qui comptent :

Taux de fiabilité des compétences : quel pourcentage de compétences planifiées s'exécutent sans erreur. Objectif supérieur à 95%.

Pertinence de la récupération mémoire : lorsque la mémoire est récupérée pour une compétence, est-elle réellement pertinente. Réviser chaque semaine.

Cohérence de la qualité des sorties : les sorties répondent-elles systématiquement à vos normes. Suivre manuellement.

Couverture opérationnelle : quel pourcentage de vos flux de travail prévus sont réellement automatisés. Viser 100% au fil du temps.

Section 14 : Le Plan de Construction sur 90 Jours

Construire une opération Hermès mature prend 90 jours d'itération constante.

Jours 1 à 7 : Fondation

Installez Hermès. Rédigez votre CLAUDE.md. Construisez la compétence de briefing matinal. Connectez les serveurs MCP Filesystem et Brave Search. Lancez votre premier briefing planifié.

Objectif : Hermès fonctionne de manière fiable et produit une sortie utile par jour.

Jours 8 à 30 : Compétences de Base

Construisez cinq à huit compétences de base pour votre opération spécifique. Configurez le planificateur pour les cinq flux de travail automatisés standard. Identifiez le premier serveur MCP spécifique à votre domaine.

Objectif : Hermès automatise 30% de votre travail de connaissance répétitif.

Jours 31 à 60 : Optimisation

Révisez la qualité de la mémoire et améliorez les conventions de stockage. Affinez les sorties des compétences en fonction de trois à quatre semaines de résultats. Construisez vos premières compétences avancées en utilisant l'exécution conditionnelle et les contrôles qualité.

Objectif : Les sorties d'Hermès répondent systématiquement aux normes de qualité sans révision manuelle.

Jours 61 à 90 : Multi-Agent

Si votre opération le justifie, concevez votre architecture multi-agent. Construisez les fichiers CLAUDE.md de l'agent spécialiste. Configurez la couche mémoire partagée. Déployez la compétence d'orchestrateur.

Objectif : Hermès gère une opération multi-agent coordonnée traitant vos flux de travail les plus complexes de bout en bout.

La Réalité Composée

Les bâtisseurs qui démarrent leur opération Hermès aujourd'hui et la font fonctionner de manière constante pendant 90 jours auront quelque chose qui ne peut pas être reproduit rapidement.

Pas parce que la technologie est difficile d'accès.

Parce que la couche mémoire qui s'accumule sur 90 jours de fonctionnement constant ne peut pas être court-circuitée.

L'agent Hermès au jour 90 connaît votre opération. Il sait quelles sources produisent le meilleur contenu pour votre public. Il sait quelles approches ont fonctionné et lesquelles ont échoué. Il connaît votre voix, vos normes et vos priorités parce qu'il les a exécutées des centaines de fois.

Cette intelligence accumulée est le fossé défensif.

Chaque jour où vous faites fonctionner l'opération, le fossé s'approfondit.

Chaque jour où vous attendez pour commencer est un jour d'intelligence composée que vous ne récupérerez jamais.

Construisez les fondations ce week-end.

Les compétences prennent un après-midi à écrire.

La mémoire commence à s'accumuler dès la première session.

La composition commence dès le premier flux de travail automatisé qui fonctionne sans vous.

Suivez @cyrilXBT pour chaque construction d'agent Hermès, modèle de compétence et architecture multi-agent qui fait fonctionner les opérations AI autonomes.