Hermes Agent : l'agent IA autonome open source que tu héberges chez toi

T'as déjà eu cette frustration : tu passes une heure à expliquer à ton assistant IA comment fonctionne ton projet, les choix techniques, les bugs que t'as résolus... et le lendemain, pouf, tout est oublié. Comme si tu parlais à un étranger à chaque nouvelle session.

Les assistants IA classiques codent, déboguent, analysent. Mais ils ont un défaut de taille : ils naissent, bossent, et meurent avec ton terminal. Aucune mémoire. Aucune continuité. Aucun moyen de leur reparler depuis ton téléphone dans le métro.

Hermes Agent, lui, il reste là. 24h/24. Dans un conteneur Docker. Prêt à répondre. Et ça change absolument tout.

---

Hermes en 30 secondes : un agent qui vit, pas un outil qu'on lance

Hermes est un agent IA conçu par Nous Research pour être ton compagnon permanent. Pas un simple script ponctuel.

C'est un service qui tourne en continu dans Docker, 24/7, même après la fermeture du terminal. Il garde une mémoire persistante : il se souvient de tes préférences, tes décisions, tes conventions de code. Tu peux y accéder par Telegram, un dashboard web, la CLI, ou une API REST. Et tu peux créer des profils isolés : un agent pour le boulot, un pour la veille, un pour l'admin sys.

---

Pourquoi Hermes fait une vraie différence

Fini la réexplication éternelle

Tu connais la routine : tu relances ton assistant, et c'est reparti pour 15 minutes de "alors comme je t'ai expliqué hier...". Avec Hermes, c'est de l'histoire ancienne.

Il garde en mémoire tes choix d'architecture, les bugs résolus, tes préférences de code, tes conventions. Il accumule les connaissances au fil des sessions. Au bout de quelques jours, il connaît ton projet sur le bout des doigts.

Ton assistant, où tu veux, comme tu veux

Hermes s'adapte à ton workflow de dev :

• Depuis ton téléphone via Telegram, pour des requêtes rapides ou de la veille.
• Depuis ton navigateur avec le dashboard natif (port 9119) ou le WebUI (port 8787).
• Depuis ton terminal en CLI classique via docker compose run --rm hermes.
• Depuis tes scripts personnels via son API REST sur le port 8642.

Un seul agent, cinq points d'entrée. Aucune friction.

Plusieurs agents, plusieurs vies

Besoin de séparer tes contextes de travail et de vie perso ? Hermes te permet de créer autant de profils isolés que tu le souhaites :

• Un agent Work pour le code, les revues et la documentation.
• Un agent Veille pour résumer des flux RSS ou des articles.
• Un agent Perso pour tes idées de projets et ton organisation.
• Un agent DevOps pour le monitoring, tes scripts d'infra et les alertes.

Chaque profil dispose de sa propre mémoire, ses propres clés d'API et sa propre personnalité. Pas de mélange de contexte.

Tes données, chez toi, sous contrôle

Pas de SaaS opaque. Pas d'abonnement mensuel forcé. Pas de données qui fuient à l'autre bout du monde.

Tout tourne sur ta machine locale dans Docker. Tes conversations et ton code restent 100% privés. Tu peux tout versionner, tout sauvegarder et migrer ta mémoire en déplaçant un simple dossier.

---

Mes cas d'usage favoris

J'utilise Hermes au quotidien pour des tâches concrètes :

• POC rapides : Je lui demande de monter une stack complète en 5 minutes. Il génère le code, le teste et me livre un dépôt propre et documenté.
• Discussions d'architecture : J'échange avec lui sur des choix techniques complexes. Il retient les nuances et me challenge de manière pertinente.
• Intégration de dépôts : Il peut cloner, lire et analyser des dépôts de code directement depuis GitHub ou GitLab.
• Veille d'issues : Il scanne mes issues GitHub, les trie par priorité et propose des patchs de résolution.
• Notifications & Tâches planifiées : Il exécute des scripts réguliers (cron) et m'envoie un rapport ou une alerte sur Telegram si un serveur tombe.

---

Le boilerplate prêt à l'emploi

Le boilerplate complet de cet article est disponible sur GitHub sous benoitpetit/hermes-agent-docker (n'hésite pas à le fork !).

Il contient le docker-compose.yml, le Dockerfile enrichi, la structure de configuration config/ et des scripts utilitaires.

Structure du projet

Copier
hermes-agent-docker/
├── docker-compose.yml      # Services Hermes + Hermes WebUI
├── Dockerfile              # Image enrichie (chromium, whisper, plugins...)
├── README.md               # Guide d'installation complet
├── scripts/
│   ├── hermes-cli          # CLI principale (contrôle, chat, setup, webui)
│   ├── sync-runtime-config.sh  # Synchronise config/ vers data_runtime/
│   ├── maintenance-data.sh # Rotation et backup des données de mémoire
│   └── ops-watchdog.sh     # Surveillance et auto-réparation
├── config/
│   ├── .env.example        # Template des variables d'environnement
│   ├── config.yaml         # Modèles, mémoire, paramètres non secrets
│   └── SOUL.md             # Personnalité de ton agent
└── data_runtime/           # Données persistantes (mémoire, logs, sessions)

L'image Docker enrichie

Le Dockerfile hérite de l'image officielle nousresearch/hermes-agent:latest et y ajoute des outils indispensables :

• Chromium + Chromium Driver : Permet à l'agent de naviguer sur le web pour lire des documentations ou tester une UI.
• Faster-Whisper : Pour la transcription de tes messages vocaux Telegram (Speech-to-Text).
• jq & curl : Pour faciliter l'exécution de scripts shell par l'agent.
• Un healthcheck automatique sur le port API 8642.

Configuration en 3 fichiers simples

Le docker-compose.yml pré-paramétré

Copier
services:
  # ── Agent principal ──────────────────────────────────
  hermes:
    build: .
    container_name: hermes
    restart: unless-stopped
    command: gateway run
    ports:
      - "127.0.0.1:8642:8642"   # API REST
      - "127.0.0.1:9119:9119"   # Dashboard Web
    volumes:
      - ./data_runtime:/opt/data
      # IMPORTANT : Ne monte pas directement config.yaml et .env individuellement à la racine de /opt/data
      # Les paramètres de l'API et du dashboard sont écrits de manière atomique (fichier temporaire + renommage).
      # Monter un fichier individuel ferait échouer l'écriture avec une erreur EBUSY.
      # Utilise le volume data_runtime à la place et le script de synchronisation.
      - ./config/SOUL.md:/opt/data/SOUL.md:ro
      - hermes-agent-src:/opt/hermes   # Partagé avec le WebUI
    environment:
      - HERMES_DASHBOARD=1
      - HERMES_UID=1000
      - HERMES_GID=1000
      - HF_TOKEN=${HF_TOKEN:-}
      - PUPPETEER_EXECUTABLE_PATH=/usr/bin/chromium
      - PUPPETEER_ARGS=--no-sandbox,--disable-setuid-sandbox,--disable-dev-shm-usage
    env_file:
      - ./config/.env
    shm_size: 1g
    deploy:
      resources:
        limits:
          memory: 4G
          cpus: "2.0"

  # ── Interface Web (Hermes WebUI) ─────────────────────
  hermes-webui:
    image: ghcr.io/nesquena/hermes-webui:latest
    container_name: hermes-webui
    depends_on:
      - hermes
    ports:
      - "127.0.0.1:8787:8787"
    volumes:
      - ./data_runtime:/home/hermeswebui/.hermes          # Config, sessions, mémoire partagées
      - hermes-agent-src:/home/hermeswebui/.hermes/hermes-agent:ro  # Source agent (deps)
      - ${HERMES_WORKSPACE:-${HOME:-/root}/workspace}:/workspace       # Navigateur de fichiers
    environment:
      - HERMES_WEBUI_HOST=0.0.0.0
      - HERMES_WEBUI_PORT=8787
      - HERMES_WEBUI_STATE_DIR=/home/hermeswebui/.hermes/webui
      - WANTED_UID=1000
      - WANTED_GID=1000
      - HERMES_SKIP_CHMOD=1
      # - HERMES_WEBUI_PASSWORD=${HERMES_WEBUI_PASSWORD:-}  # Décommente pour protéger l'accès
    restart: unless-stopped

volumes:
  hermes-agent-src:          # Volume partagé du code source de l'agent

---

Déploiement en 5 minutes chrono

1. Clone et prépare l'environnement

Copier
git clone https://github.com/benoitpetit/hermes-agent-docker.git
cd hermes-agent-docker

# Crée tes fichiers de config locaux
cp config/.env.example config/.env
nano config/.env

2. Choisis ton modèle IA

Ouvre config/config.yaml et configure ton provider préféré (Ollama en local, OpenRouter pour le cloud, Anthropic, OpenAI, etc.) :

Copier
model:
  provider: openrouter
  default: deepseek/deepseek-v4-flash:free # Version gratuite rapide

3. Configure Telegram (recommandé)

1. Discute avec @BotFather sur Telegram pour créer un nouveau bot et obtenir ton token.
2. Copie le token dans la variable TELEGRAM_BOT_TOKEN de ton fichier .env.
3. Récupère ton ID Telegram personnel (via un bot comme @userinfobot) et ajoute-le dans TELEGRAM_ALLOWED_USERS pour sécuriser l'accès à ton bot.

4. Initialise et synchronise la configuration (Indispensable)

Comme expliqué plus haut, Hermes lit ses fichiers de configuration dynamiquement depuis le dossier de runtime monté (data_runtime/). Pour propager tes modifications du dossier config/ vers le runtime, tu dois exécuter le script de synchronisation fourni :

Copier
# Synchronise config.yaml et .env vers data_runtime/
./scripts/sync-runtime-config.sh

(Note : Si tu lances Hermes via le script interactif hermes-cli comme décrit plus bas, cette synchronisation est automatique !)

5. Lance le conteneur

Pour démarrer les conteneurs (l'agent + l'interface web WebUI), tu as deux méthodes :

Option A (Recommandée) : Via le script CLI unifié Le script gère la synchronisation de configuration automatiquement et démarre les services proprement :

Copier
./scripts/hermes-cli start

Option B : Via docker compose brut Si tu préfères la commande Docker classique (assure-toi d'avoir exécuté l'étape 4 de synchronisation au préalable) :

Copier
docker compose up -d

Tu peux vérifier que tout fonctionne correctement :

Copier
# Test de l'API healthcheck
curl http://localhost:8642/health

# Lecture des logs de démarrage
docker compose logs -f hermes hermes-webui

Rends-toi sur http://localhost:9119 pour accéder au dashboard web d'administration, ou sur http://localhost:8787 pour l'interface WebUI (Hermes WebUI).

6. Interagis avec ton agent

Copier
# Ouvre le menu interactif ou lance une conversation dans ton terminal
./scripts/hermes-cli

# Exécute un diagnostic système
./scripts/hermes-cli doctor

# Gérer l'interface WebUI (status, logs, restart)
./scripts/hermes-cli webui status
./scripts/hermes-cli webui logs
./scripts/hermes-cli webui restart

---

Hermes WebUI : ton agent dans le navigateur

Le boilerplate embarque aussi Hermes WebUI, une interface web sombre et légère qui offre une parité quasi-totale avec le CLI. Tout ce que tu fais en terminal est disponible depuis le navigateur.

Architecture

• hermes : gateway + dashboard (inchangé)
• hermes-webui : interface web, démarre son propre agent in-process
• data_runtime/ : volume partagé (config, sessions, skills, mémoire)

Les deux conteneurs partagent data_runtime/ : les sessions créées depuis le WebUI apparaissent dans le gateway et vice-versa.

Accès rapide

Copier
# Tout est lancé d'un coup
docker compose up -d

# Ouvrir dans le navigateur
xdg-open http://localhost:8787

# Ou via le menu interactif (option 15)
./scripts/hermes-cli menu

Configuration

Le WebUI détecte automatiquement ta configuration Hermes existante (provider, modèle, skills). Quelques variables optionnelles dans config/.env :

Exemple avec mot de passe et workspace personnalisé :

Copier
echo "HERMES_WEBUI_PASSWORD=mon-super-mot-de-passe" >> config/.env
echo "HERMES_WORKSPACE=/home/ben/projets" >> config/.env
docker compose up -d --force-recreate hermes-webui

Mode gateway (chat back-end)

Par défaut, le WebUI lance son propre agent in-process. Tu peux le faire transiter par le gateway de l'agent principal pour partager la même session :

Copier
HERMES_WEBUI_CHAT_BACKEND=gateway \
HERMES_WEBUI_GATEWAY_BASE_URL=http://hermes:8642 \
HERMES_WEBUI_GATEWAY_API_KEY=ta-cle-api \
docker compose up -d --force-recreate hermes-webui

---

Pour aller plus loin

• Dépôt officiel du projet : github.com/NousResearch/hermes-agent
• Documentation officielle : hermes-agent.nousresearch.com/docs
• Hermes WebUI : github.com/nesquena/hermes-webui
• Créateur de bot Telegram : t.me/BotFather

---

Tu as déjà testé Hermes Agent ou tu as des idées de workflows à partager ? Viens en parler sur Mastodon ou sur Bluesky !