Skills et plugins Hermes Agent : creation, installation, partage et securite

Introduction

Les skills et les plugins sont les deux mecanismes d'extension de Hermes Agent. Les skills sont des documents de connaissance charges a la demande par l'agent -- sa memoire procedurale. Les plugins sont des modules de code Python qui etendent le moteur lui-meme. Cette page couvre les deux systemes : ce qu'ils sont, comment les creer, les installer, les partager et les securiser.

Les skills suivent le standard ouvert agentskills.io et sont portables entre agents compatibles. Hermes Agent integre un hub de skills avec 8 sources differentes, un scanner de securite integre, et un systeme de bundles pour organiser les skills par metier.

Questions couvertes

q-071: Qu'est-ce qu'une skill Hermes Agent ?

Une skill est un document de connaissance structure (fichier SKILL.md avec frontmatter YAML) que l'agent charge a la demande pour accomplir une tache specifique. C'est la memoire procedurale de Hermes Agent : quand l'agent decouvre un workflow non trivial, il le sauvegarde comme skill pour le reutiliser dans les sessions futures.

Les skills resident dans ~/.hermes/skills/, organisees par categories (dossiers comme devops/, mlops/, creative/). Chaque skill est un repertoire contenant :

• SKILL.md (obligatoire) -- les instructions principales
• references/ -- documentation supplementaire
• templates/ -- formats de sortie
• scripts/ -- scripts auxiliaires
• assets/ -- fichiers statiques

Les skills utilisent un pattern de divulgation progressive a trois niveaux pour minimiser la consommation de tokens :

1. Niveau 0 : skills_list() retourne la liste de toutes les skills installees (nom + description) -- environ 3k tokens
2. Niveau 1 : skill_view(name) charge le contenu complet de la skill
3. Niveau 2 : skill_view(name, path) charge un fichier de reference specifique

Chaque skill installee est automatiquement disponible comme commande slash (/nom-de-la-skill) dans le CLI, le TUI, le dashboard et toutes les plateformes de messagerie.

L'agent peut aussi creer, modifier et supprimer ses propres skills via l'outil skill_manage. Il le fait typiquement apres avoir reussi une tache complexe (5+ appels d'outils), surmonte des erreurs, ou decouvert un workflow non trivial.

Sources : Documentation officielle Hermes Agent -- Skills System, commit b4f8c491.

q-072: Quelle difference entre une skill, un plugin et un outil ?

Ces trois concepts operent a des niveaux differents de la pile Hermes Agent :

Skills : Ce sont des instructions, pas du code. Elles disent a l'agent comment faire quelque chose en utilisant les outils dont il dispose deja. Elles ne peuvent pas ajouter de nouvelles capacites au moteur -- seulement guider l'agent existant.

Plugins : Ce sont des modules Python installes dans ~/.hermes/plugins/ qui etendent le moteur de Hermes Agent. Ils peuvent ajouter de nouveaux outils, de nouvelles plateformes de messagerie, des providers de memoire, des context engines, et plus encore. Ils s'executent dans le meme processus que Hermes.

Outils (tools) : Ce sont les fonctions atomiques que l'agent appelle pour interagir avec le monde : lire un fichier, executer une commande shell, rechercher sur le web. Les outils sont regroupes en toolsets (ensembles d'outils) comme web, terminal, file, browser. Les outils natifs sont fournis par Hermes ; les plugins et les serveurs MCP peuvent en ajouter.

En resume : une skill dit a l'agent quoi faire, un outil lui permet de le faire, un plugin ajoute de nouvelles capacites au moteur.

Sources : Documentation officielle -- Skills System, Plugins, Tools & Toolsets.

q-073: Comment rechercher et installer une skill Hermes Agent ?

Hermes Agent integre un hub de skills avec 8 sources differentes. La recherche et l'installation se font via la CLI hermes skills.

Rechercher une skill :

# Parcourir toutes les skills du hub (officielles en premier)
hermes skills browse

# Filtrer par source
hermes skills browse --source official

# Rechercher par mot-cle
hermes skills search kubernetes
hermes skills search react --source skills-sh
hermes skills search https://mintlify.com/docs --source well-known

# Inspecter avant d'installer
hermes skills inspect openai/skills/k8s
hermes skills inspect skills-sh/vercel-labs/json-render/json-render-react

Installer une skill :

# Depuis les skills officielles optionnelles
hermes skills install official/security/1password

# Depuis un depot GitHub (OpenAI, Anthropic, NVIDIA, HuggingFace...)
hermes skills install openai/skills/k8s

# Depuis skills.sh (annuaire public de Vercel)
hermes skills install skills-sh/vercel-labs/json-render/json-render-react --force

# Depuis un endpoint well-known
hermes skills install well-known:https://mintlify.com/docs/.well-known/skills/mintlify

# Depuis une URL directe
hermes skills install https://sharethis.chat/SKILL.md

# Depuis un tap personnalise
hermes skills tap add myorg/skills-repo
hermes skills install myorg/skills-repo/deploy-runbook

Les 8 sources integrees :

Toutes les skills installees depuis le hub passent par un scanner de securite qui verifie l'exfiltration de donnees, l'injection de prompt, les commandes destructrices et les signaux de supply chain. Le flag --force permet de passer les blocages non dangereux (caution/warn), mais ne peut jamais outrepasser un verdict dangerous.

Niveaux de confiance :

Sources : Documentation officielle -- Skills Hub, CLI Commands Reference.

q-074: Comment creer une skill reutilisable pour Hermes Agent ?

Il y a deux facons de creer une skill : manuellement en redigeant un fichier SKILL.md, ou automatiquement avec la commande /learn.

Methode 1 : Creation manuelle

Creez un repertoire dans ~/.hermes/skills/<categorie>/<nom-de-la-skill>/ contenant un fichier SKILL.md :

---
name: ma-skill
description: Description courte (max 60 caracteres) de ce que fait la skill
version: 1.0.0
platforms: [linux, macos]
metadata:
  hermes:
    tags: [python, automatisation]
    category: devops
    requires_toolsets: [terminal]
---

# Titre de la skill

## When to Use
Conditions de declenchement de cette skill.

## Procedure
1. Etape un
2. Etape deux

## Pitfalls
- Modes d'echec connus et corrections

## Verification
Comment confirmer que ca a fonctionne.

Champs optionnels importants du frontmatter :

• platforms : restreindre a certains OS ([macos], [linux], [windows])
• metadata.hermes.fallback_for_toolsets : afficher la skill uniquement quand un toolset est absent (skills de secours)
• metadata.hermes.requires_toolsets : afficher la skill uniquement quand un toolset est present
• metadata.hermes.config : declarer des parametres de configuration stockes dans config.yaml
• required_environment_variables : declarer des variables d'environnement necessaires

Methode 2 : Creation automatique avec /learn

/learn est le moyen rapide de transformer du materiel de reference en skill reutilisable :

# Un repertoire local
/learn le client REST dans ~/projects/acme-sdk, focus sur auth + pagination

# Une page de documentation en ligne
/learn https://docs.example.com/api/quickstart

# Un workflow que vous venez de realiser avec l'agent
/learn comment je viens de deployer le serveur de staging

L'agent rassemble le materiel avec ses outils, puis redige une skill conforme aux standards (description <60 caracteres, ordre standard des sections, pas de commandes inventees).

Bonnes pratiques pour une skill reutilisable :

• La description dans le frontmatter est critique : c'est ce que l'agent voit dans l'index des skills. Elle doit etre suffisamment precise pour que l'agent sache quand charger la skill.
• Utilisez des conditions de declenchement claires dans la section "When to Use".
• Documentez les pieges connus dans "Pitfalls".
• Ajoutez une section "Verification" pour que l'agent puisse confirmer que la tache est reussie.
• Pour les skills avec des fichiers de support, utilisez les sous-dossiers references/, templates/, scripts/.

Sources : Documentation officielle -- SKILL.md Format, Learning a skill from sources.

q-075: Comment tester qu'une skill se declenche au bon moment ?

Le declenchement d'une skill depend de deux mecanismes : le matching automatique par l'agent et l'invocation explicite par l'utilisateur.

1. Invocation explicite (test immediat)

La facon la plus fiable de tester une skill est de l'invoquer explicitement :

/ma-skill
/ma-skill fais ceci

Si la skill est installee, elle apparait dans la liste des commandes slash et se charge immediatement.

2. Declenchement automatique (test de matching)

Pour qu'une skill se declenche automatiquement, l'agent doit juger qu'elle est pertinente pour la tache en cours. Cela depend de :

• La description dans le frontmatter YAML -- c'est le seul texte que l'agent voit dans l'index des skills (niveau 0)
• Les conditions de declenchement dans la section "When to Use" (visibles seulement au niveau 1)
• Les conditions d'activation (requires_toolsets, fallback_for_toolsets, requires_tools, fallback_for_tools)

Verification du matching :

# Verifier que la skill apparait dans l'index
hermes chat --toolsets skills -q "Quelles skills sont disponibles ?"

# Tester avec une requete qui devrait matcher
hermes chat --toolsets skills -q "Fais [tache que la skill couvre]"

# Verifier les conditions d'activation
hermes chat --toolsets skills -q "Quelles skills sont disponibles ?" --toolsets web
# Puis sans le toolset web pour tester les fallback skills
hermes chat --toolsets skills -q "Quelles skills sont disponibles ?"

3. Test des conditions d'activation conditionnelle

Les skills peuvent utiliser ces champs pour controler leur visibilite :

metadata:
  hermes:
    fallback_for_toolsets: [web]      # Cachee si le toolset web est disponible
    requires_toolsets: [terminal]     # Cachee si le toolset terminal est absent
    fallback_for_tools: [web_search]  # Cachee si l'outil web_search est disponible
    requires_tools: [terminal]        # Cachee si l'outil terminal est absent

Pour tester : activez ou desactivez le toolset concerne via hermes tools, puis verifiez si la skill apparait ou disparait de l'index.

4. Test de la restriction de plateforme

platforms: [macos]  # Visible seulement sur macOS

La skill est automatiquement masquee sur les plateformes incompatibles. Testez en lancant Hermes sur differentes plateformes.

5. Audit de l'index des skills

# Voir la taille de l'index des skills dans le prompt systeme
hermes prompt-size

# Verifier quelles skills sont installees
hermes skills list

Sources : Documentation officielle -- Conditional Activation, Platform-Specific Skills.

q-076: Comment partager une bibliotheque de skills entre plusieurs profils ?

Hermes Agent propose trois mecanismes pour partager des skills entre profils :

1. Repertoires de skills externes (recommande pour le partage local)

Ajoutez des repertoires partages dans config.yaml :

skills:
  external_dirs:
    - ~/.agents/skills
    - /home/shared/team-skills
    - ${SKILLS_REPO}/skills

Les chemins supportent l'expansion ~ et la substitution de variables d'environnement ${VAR}.

Comportement :

• Les skills externes apparaissent dans l'index, skills_list, skill_view et comme commandes slash -- exactement comme les skills locales
• Precedence locale : si le meme nom de skill existe en local et en externe, la version locale gagne
• Repertoires inexistants ignores : si un repertoire configure n'existe pas, Hermes l'ignore sans erreur
• Modification in-place : les skills externes sont modifiables par l'agent si le processus Hermes a les droits d'ecriture

2. Taps GitHub (recommande pour le partage d'equipe)

Publiez vos skills dans un depot GitHub et ajoutez-le comme tap :

# Ajouter un tap
hermes skills tap add mon-org/skills-equipe

# Les membres de l'equipe installent les skills
hermes skills search deploy
hermes skills install mon-org/skills-equipe/deploy-runbook

Structure du depot :

mon-org/skills-equipe
└── skills/
    ├── deploy-runbook/
    │   └── SKILL.md
    └── incident-response/
        └── SKILL.md

3. Clonage de profil

Lors de la creation d'un nouveau profil, clonez les skills du profil existant :

hermes profile create nouveau-profil --clone

L'option --clone copie la configuration, le .env, le SOUL.md et les skills du profil actif. --clone-all copie tout l'etat (sessions, memoire, etc.).

4. Bundles de skills (pour les workflows recurrents)

Pour les combinaisons de skills utilisees ensemble, creez un bundle :

hermes bundles create backend-dev \
  --skill github-code-review \
  --skill test-driven-development \
  --skill github-pr-workflow \
  -d "Backend feature work"

Le bundle est un fichier YAML dans ~/.hermes/skill-bundles/ qui peut etre symlinke depuis un depot partage.

Sources : Documentation officielle -- External Skill Directories, Publishing a custom skill tap, Skill Bundles.

q-077: Comment mettre a jour ou supprimer une skill installee ?

Mise a jour des skills du hub :

# Verifier quelles skills ont des mises a jour disponibles
hermes skills check

# Mettre a jour toutes les skills du hub qui ont change
hermes skills update

# Mettre a jour une skill specifique
hermes skills update react

Le hub trace la provenance de chaque skill installee (source, identifiant, hash du contenu) et peut detecter les changements upstream.

Mise a jour des skills bundlees :

Les skills livrees avec Hermes sont synchronisees a chaque hermes update. Hermes compare le hash local au hash d'origine :

• Inchangee : la nouvelle version est copiee
• Modifiee par l'utilisateur : la skill est marquee user_modified et n'est jamais ecrasee

Pour revenir a la version bundlee :

# Reinitialiser le suivi (conserve votre copie actuelle)
hermes skills reset google-workspace

# Restaurer la version bundlee (efface vos modifications)
hermes skills reset google-workspace --restore

Suppression d'une skill :

# Supprimer une skill installee depuis le hub
hermes skills uninstall k8s

# Supprimer une skill creee par l'agent ou manuellement
# Supprimez simplement le repertoire dans ~/.hermes/skills/
rm -rf ~/.hermes/skills/devops/ma-skill

Desactiver les skills bundlees :

# Empecher le seeding futur des skills bundlees (ne supprime rien)
hermes skills opt-out

# Supprimer aussi les skills bundlees non modifiees
hermes skills opt-out --remove

# Revenir en arriere
hermes skills opt-in --sync

Audit de securite :

# Re-scanner toutes les skills du hub
hermes skills audit

Sources : Documentation officielle -- Update lifecycle, Bundled skill updates, CLI Commands Reference.

q-078: Comment installer un plugin Hermes Agent en securite ?

Les plugins sont des modules Python qui s'executent dans le meme processus que Hermes Agent. Ils ont donc un acces complet au systeme. L'installation securisee est essentielle.

Installation d'un plugin :

# Depuis un depot Git
hermes plugins install https://github.com/user/hermes-plugin

# Depuis un identifiant owner/repo
hermes plugins install owner/repo

# Avec force (pour les plugins communautaires)
hermes plugins install owner/repo --force

Bonnes pratiques de securite pour l'installation :

1. Verifier la source : preferez les plugins de sources connues et verifiees. Les plugins officiels de Nous Research sont les plus surs.

2. Inspecter avant d'activer : installez le plugin mais laissez-le desactive, puis inspectez le code avant de l'activer :

hermes plugins install owner/repo
# Le plugin est installe mais desactive
# Inspectez le code dans ~/.hermes/plugins/<nom>/
hermes plugins enable <nom>  # Seulement apres inspection

3. Utiliser le scanner de securite :

# Audit de la supply chain (OSV.dev)
hermes security audit

# Inclut les dependances des plugins
hermes security audit --skip-venv

4. Principe de moindre privilege : n'activez que les plugins dont vous avez reellement besoin. Desactivez ceux qui ne sont pas utilises :

hermes plugins disable <nom>
hermes plugins list  # Verifier l'etat de tous les plugins

5. Isolation par profil : utilisez des profils separes pour tester les nouveaux plugins avant de les deployer sur votre profil principal :

hermes profile create test --clone
hermes -p test plugins install owner/repo
# Testez dans le profil isole

Gestion des plugins :

# Interface interactive (activation/desactivation, providers)
hermes plugins

# Lister les plugins installes
hermes plugins list

# Mettre a jour un plugin
hermes plugins update <nom>

# Supprimer un plugin
hermes plugins remove <nom>

Sources : Documentation officielle -- Plugins, Security, CLI Commands Reference.

q-079: Comment verifier les permissions et le code d'un plugin ?

La verification d'un plugin se fait en trois etapes : inspection du code, audit de securite, et verification des permissions.

1. Inspection du code source

Les plugins installes resident dans ~/.hermes/plugins/<nom>/. Inspectez le code avant activation :

# Lister les fichiers du plugin
ls -la ~/.hermes/plugins/<nom>/

# Lire le point d'entree principal
cat ~/.hermes/plugins/<nom>/__init__.py

# Verifier les dependances declarees
cat ~/.hermes/plugins/<nom>/requirements.txt
cat ~/.hermes/plugins/<nom>/pyproject.toml

Points a verifier dans le code :

• Appels reseau : le plugin communique-t-il avec des serveurs externes ?
• Acces au systeme de fichiers : quels fichiers lit-il ou ecrit-il ?
• Execution de code arbitraire : y a-t-il des eval(), exec(), subprocess ?
• Collecte de donnees : le plugin accede-t-il a vos conversations, votre configuration, vos cles API ?

2. Audit de securite automatise

# Audit complet de la supply chain (venv + plugins + MCP)
hermes security audit

# Audit avec sortie JSON pour analyse automatisee
hermes security audit --json

# Niveau de severite pour echec
hermes security audit --fail-on high

L'audit interroge OSV.dev et couvre :

• Les distributions PyPI dans le venv de Hermes
• Les dependances declarees par les plugins sous ~/.hermes/plugins/
• Les serveurs MCP pinnees dans config.yaml

3. Verification des permissions effectives

Les plugins n'ont pas de systeme de permissions granulaire integre -- ils s'executent avec les memes droits que le processus Hermes. Pour limiter les risques :

• Lancez Hermes avec un utilisateur dedie aux droits limites
• Utilisez un backend terminal isole (Docker, SSH, Modal) pour les taches a risque
• Activez le mode approbation (approvals.mode: smart ou manual) pour les commandes dangereuses
• Utilisez --safe-mode pour isoler un probleme : hermes chat --safe-mode -q "test"

4. Surveillance continue

# Verifier les logs pour des comportements suspects
hermes logs agent --level WARNING
hermes logs errors

# Verifier l'etat des plugins
hermes plugins list
hermes doctor

Sources : Documentation officielle -- Security, CLI Commands Reference, Plugins.

q-080: Comment organiser des bundles de skills par metier ?

Les skill bundles sont des fichiers YAML qui regroupent plusieurs skills sous une seule commande slash. Ils permettent d'organiser les skills par metier, par projet ou par workflow recurrent.

Creer un bundle par metier :

# Bundle pour le developpement backend
hermes bundles create backend-dev \
  --skill github-code-review \
  --skill test-driven-development \
  --skill github-pr-workflow \
  -d "Developpement backend : review, tests, PR"

# Bundle pour la preparation de release
hermes bundles create release-prep \
  --skill changelog-generator \
  --skill version-bumper \
  --skill deploy-runbook \
  -d "Preparation de release : changelog, version, deploy"

# Bundle pour la reponse aux incidents
hermes bundles create incident-response \
  --skill log-analyzer \
  --skill rollback-procedure \
  --skill status-page-update \
  -d "Reponse aux incidents : diagnostic, rollback, communication"

Schema YAML d'un bundle :

name: backend-dev
description: Developpement backend : review, tests, PR.
skills:
  - github-code-review
  - test-driven-development
  - github-pr-workflow
instruction: |
  Always start by writing failing tests, then implement.
  Open the PR through the standard workflow with co-author tags.

Champs :

• name (optionnel, defaut : nom du fichier) -- nom d'affichage du bundle
• description (optionnel) -- texte court affiche dans /bundles et hermes bundles list
• skills (obligatoire, liste non vide) -- noms des skills a charger
• instruction (optionnel) -- guidance supplementaire prependee au contenu charge

Utilisation au quotidien :

# Dans le CLI ou n'importe quelle plateforme de messagerie
/backend-dev refactorer le middleware d'auth
/release-prep preparer la release v2.3.0
/incident-response l'API /users retourne 500

Gestion des bundles :

# Lister tous les bundles
hermes bundles list

# Inspecter un bundle
hermes bundles show backend-dev

# Creer interactivement (sans --skill, entree une par ligne)
hermes bundles create recherche

# Supprimer un bundle
hermes bundles delete backend-dev

# Re-scanner le repertoire des bundles
hermes bundles reload

Dans une session de chat, /bundles liste tous les bundles installes.

Strategie d'organisation par metier :

Partage des bundles en equipe :

Les bundles sont des fichiers YAML dans ~/.hermes/skill-bundles/. Pour les partager :

1. Creez un depot Git avec les fichiers YAML des bundles
2. Les membres de l'equipe symlinkent ou copient les bundles dans leur ~/.hermes/skill-bundles/
3. Les skills referencees doivent etre installees separement (le bundle ne les installe pas)

# Exemple de symlink depuis un depot partage
ln -s ~/team-dotfiles/hermes/bundles/backend-dev.yaml ~/.hermes/skill-bundles/backend-dev.yaml
hermes bundles reload

Comportement important :

• Les bundles prennent priorite sur les skills individuelles en cas de collision de nom
• Les skills manquantes sont ignorees (pas d'erreur fatale)
• Les bundles fonctionnent sur toutes les surfaces (CLI, TUI, dashboard, messagerie)
• Les bundles n'invalident pas le cache de prompt

Sources : Documentation officielle -- Skill Bundles, CLI Commands Reference.

Sources

• Documentation officielle Hermes Agent -- Skills System (https://hermes-agent.nousresearch.com/docs/user-guide/features/skills)
• Documentation officielle Hermes Agent -- Plugins (https://hermes-agent.nousresearch.com/docs/user-guide/features/plugins)
• Documentation officielle Hermes Agent -- Security (https://hermes-agent.nousresearch.com/docs/user-guide/security)
• CLI Commands Reference (https://hermes-agent.nousresearch.com/docs/reference/cli-commands)
• Depot NousResearch/hermes-agent (https://github.com/NousResearch/hermes-agent), commit b4f8c491
• Standard agentskills.io (https://agentskills.io/specification)

Liens internes proposes

• Comprendre Hermes Agent
• Configurer Hermes Agent
• Sources
• Methodologie