Vous avez construit un Hermes Agent. Il fonctionne. Puis un client vous dit : "Je peux en avoir un comme ça ?"

L'avantage du solopreneur, c'est construire une fois, vendre à plusieurs. Hermes propose une isolation basée sur les profils qui constitue la bonne fondation pour les déploiements multi-clients — mais les profils seuls ne constituent pas une frontière de sécurité complète. Cet article montre ce que les profils isolent réellement, où vous devez ajouter du sandboxing, et comment les tableaux Kanban maintiennent l'organisation du travail multi-équipes.

Que Sont les Profils Hermes ?

Un profil est une instance d'agent complètement indépendante avec sa propre config.yaml, .env, SOUL.md, stockage mémoire, historique de sessions, skills, tâches cron et état de gateway.

hermes profile create acme
# Maintenant : acme chat, acme gateway start, acme cron list

Ce que les profils isolent : L'état Hermes. Le Profil A ne peut pas lire la mémoire, les sessions ou les tâches cron du Profil B.

Ce que les profils n'isolent PAS : Le système de fichiers. Sur le backend terminal local par défaut, chaque profil s'exécute en tant qu'utilisateur OS avec les mêmes accès fichiers que tout autre processus que vous possédez.

Hermes Agent Peut-il supporter Plusieurs Clients sur un Seul Serveur ?

Oui — avec les bonnes barrières de sécurité.

La Réalité de l'Isolation

Couche	Isolée par les Profils ?	Ce que Vous Devez Ajouter
Mémoire (SQLite DB)	Totalement	Rien
Sessions	Totalement	Rien
Clés API (`.env`)	Totalement	Rien
Bot Telegram	Verrouillage de token appliqué	Un token par gateway en cours d'exécution
Système de fichiers	Non sur le backend local	`terminal.cwd`, Docker, SSH ou backends Modal
Exécution	Non sur le backend local	Sandbox Docker, Modal ou Singularity
Visibilité du tableau de bord	Le tableau de bord partagé peut exposer les profils et le travail Kanban sur le même hôte	Garder le tableau de bord partagé privé ; un tableau de bord orienté client nécessite un runtime Hermes isolé séparé, pas seulement un processus à portée de profil

Sans restrictions de système de fichiers ou de sandbox, une session orientée client peut accéder aux fichiers disponibles pour le compte utilisateur de l'hôte. Associez toujours les profils à un backend terminal sandboxé pour le travail orienté client.

Vue d'ensemble de l'Architecture

external_users { # Clients Externes
  n1: circle label="Utilisateur Client A"
  n2: circle label="Utilisateur Client B"
}

shared_host { # Environnement Hôte Partagé
  n3: rectangle label="Reverse Proxy"
  n4: rectangle label="Gateway Partagé"
  n5: rectangle label="Tableau de Bord Admin"
  n6: rectangle label="Profil : acme"
  n7: rectangle label="Profil : beta"
  n8: rectangle label="kanban.db"
  n9: rectangle label="Système de Fichiers Hôte"
}

client_a_tools { # Interne Client A
  n10: rectangle label="Outils ingénierie"
  n11: rectangle label="Outils support"
  n12: rectangle label="Outils recherche"
}

external_users.n1.handle(right) -> shared_host.n3.handle(left) [label="webhook"]
external_users.n2.handle(right) -> shared_host.n3.handle(left) [label="webhook"]
shared_host.n3.handle(right) -> shared_host.n4.handle(left)
shared_host.n4.handle(right) -> shared_host.n6.handle(left) [label="Token A"]
shared_host.n4.handle(bottom) -> shared_host.n7.handle(top) [label="Token B"]
shared_host.n4.handle(top) -> shared_host.n5.handle(bottom) [label="ops only"]
shared_host.n6.handle(right) -> client_a_tools.n10.handle(left) [label="/engineering"]
shared_host.n6.handle(right) -> client_a_tools.n11.handle(left) [label="/support"]
shared_host.n6.handle(bottom) -> client_a_tools.n12.handle(top) [label="/research"]
shared_host.n6.handle(bottom) -> shared_host.n8.handle(top) [label="shared board"]
shared_host.n7.handle(bottom) -> shared_host.n8.handle(top) [label="shared board"]
shared_host.n6.handle(bottom) -> shared_host.n9.handle(top) [label="local backend risk"]
shared_host.n7.handle(bottom) -> shared_host.n9.handle(top) [label="local backend risk"]

Critique : Le Problème du Tableau de Bord

Une seule instance du tableau de bord Hermes pointant vers le runtime Hermes partagé montre le travail de plus d'un profil sur le même hôte.

Ce n'est pas un portail multi-tenant orienté client. C'est une console opérateur interne. La documentation Kanban est explicite : Kanban est partagé entre tous les profils Hermes, stocké dans ~/.hermes/kanban.db, et les tâches sont conçues comme agnostiques de profil.

La solution est simple :

Gardez le tableau de bord partagé comme votre console ops privée. Ne donnez jamais aux clients accès à celui-ci.
Pour les tableaux de bord orientés clients, exécutez un runtime Hermes isolé séparé par client, pas seulement un processus de tableau de bord à portée de profil. En pratique, cela signifie une installation séparée, un conteneur, une VM, ou au minimum une limite utilisateur OS/runtime séparée.
Mettez chacun derrière son propre sous-domaine avec authentification (reverse proxy nginx + auth basique ou OAuth). Ne laissez jamais un client atteindre l'instance partagée.
Ou ignorez complètement le tableau de bord — de nombreux solopreneurs opèrent purement via des canaux Telegram et n'exposent jamais d'interface web aux clients.

La règle est simple : un tableau de bord visible par le client = un runtime Hermes isolé. Si un client a besoin d'une séparation plus forte, déplacez-le vers un hôte ou conteneur séparé avec sa propre installation Hermes.

Les Profils Hermes Sont-ils Assez Sécurisés pour l'Usage Multi-Tenant ?

Les profils sont une fondation, pas une solution complète. La sécurité dépend de ce que vous ajoutez autour.

Checklist de Sécurité Minimum

# 1. Profil frais (jamais --clone depuis le personnel)
hermes profile create client-x

# 2. Restreindre l'espace de travail
client-x config set terminal.cwd /var/hermes-clients/client-x

# 3. Utiliser un backend sandboxé
client-x config set terminal.backend docker

# 4. Définir un token de bot séparé
nano ~/.hermes/profiles/client-x/.env
# TELEGRAM_BOT_TOKEN=789012:ABC-DEF-...

# 5. Désactiver les toolsets non pertinents
client-x config set agent.disabled_toolsets '["flowzap","creative","media"]'

# 6. Démarrer sa gateway
client-x gateway start

Pourquoi --clone est risqué : Cela copie votre config personnelle, clés API et mémoire dans le nouveau profil. Créez toujours des profils frais pour les clients.

Tokens de Bot Telegram

Chaque gateway en cours d'exécution doit utiliser son propre token de bot. Si deux profils partagent le même token, la seconde gateway est bloquée avec une erreur claire.

ERROR: [Telegram] Bot token already in use by profile acme (PID X).

Pour les clients multi-départements, utilisez soit un profil avec routage interne (plus simple), soit créez plusieurs bots Telegram avec des tokens séparés.

Options d'Architecture : 4 Patterns de Configuration

Option 1 : Un Client, Un Département

external_actor { # Acteur Externe
  n1: circle label="Utilisateur Client"
}

hermes_runtime { # Runtime Hermes
  n2: rectangle label="Bot Telegram"
  n3: rectangle label="Gateway"
  n4: rectangle label="Profil : client-x"
}

execution_sandbox { # Limite d'Exécution
  n5: rectangle label="Espace de Travail Isolé"
}

external_actor.n1.handle(right) -> hermes_runtime.n2.handle(left) [label="message"]
hermes_runtime.n2.handle(right) -> hermes_runtime.n3.handle(left)
hermes_runtime.n3.handle(right) -> hermes_runtime.n4.handle(left) [label="routes"]
hermes_runtime.n4.handle(right) -> execution_sandbox.n5.handle(left) [label="exécute code"]

Utiliser pour : Premier client, preuve de concept, bots Q&A simples.

Option 2 : Un Client, Plusieurs Départements (Routage Interne)

Un profil, un bot. Le SOUL.md route par préfixe (/engineering, /support).

team_users { # Points d'entrée Client
  n1: circle label="Utilisateur Équipe"
}

entry_point { # Bot & Routage
  n2: rectangle label="Bot Partagé"
  n3: rectangle label="Gateway"
  n4: diamond label="Routeur par Préfixe"
}

hermes_profile { # Profil Unifié
  n5: rectangle label="Profil : acme"
}

department_modes { # Logique Interne
  n6: rectangle label="Mode Ingénierie"
  n7: rectangle label="Mode Support"
}

team_users.n1.handle(right) -> entry_point.n2.handle(left) [label="/eng ou /support"]
entry_point.n2.handle(right) -> entry_point.n3.handle(left)
entry_point.n3.handle(right) -> entry_point.n4.handle(left)
entry_point.n4.handle(right) -> hermes_profile.n5.handle(left) [label="charge profil"]
hermes_profile.n5.handle(right) -> department_modes.n6.handle(left) [label="si /eng"]
hermes_profile.n5.handle(right) -> department_modes.n7.handle(left) [label="si /support"]

Utiliser pour : Un client avec 2-3 équipes partageant un canal de chat.

Option 3 : Plusieurs Clients, Bots Séparés (Multi-Tenant de Base)

Chaque client obtient son propre token de bot, gateway et profil isolé.

external_tenants { # Locataires Externes
  n1: circle label="Utilisateur Client A"
  n2: circle label="Utilisateur Client B"
}

client_gateways { # Points d'entrée par Token
  n3: rectangle label="Gateway A"
  n4: rectangle label="Gateway B"
}

hermes_profiles { # Profils Isolés
  n5: rectangle label="Profil : acme"
  n6: rectangle label="Profil : beta"
}

execution_sandboxes { # Limites d'Exécution
  n7: rectangle label="Sandbox A"
  n8: rectangle label="Sandbox B"
}

external_tenants.n1.handle(right) -> client_gateways.n3.handle(left) [label="Token A"]
external_tenants.n2.handle(right) -> client_gateways.n4.handle(left) [label="Token B"]
client_gateways.n3.handle(right) -> hermes_profiles.n5.handle(left)
client_gateways.n4.handle(right) -> hermes_profiles.n6.handle(left)
hermes_profiles.n5.handle(right) -> execution_sandboxes.n7.handle(left) [label="Docker / Modal"]
hermes_profiles.n6.handle(right) -> execution_sandboxes.n8.handle(left) [label="Docker / Modal"]

Utiliser pour : 2+ clients payants. Chacun a "son propre bot" depuis un seul serveur.

Astuce : Créez des profils frais (hermes profile create client-x), jamais --clone. Pas de clés API héritées, pas de fuites de mémoire cross-client.

Option 4 : Multi-Tenant Complet avec Départements

client_users { # Participants Externes
  n1: circle label="Utilisateurs Acme"
  n2: circle label="Utilisateurs Beta"
}

entry_gateways { # Gateways Clients
  n3: rectangle label="Gateway Acme"
  n4: rectangle label="Gateway Beta"
}

hermes_profiles { # Profils Routés
  n5: diamond label="Routeur Acme"
  n6: rectangle label="acme-eng"
  n7: rectangle label="acme-support"
  n8: rectangle label="beta"
}

execution_sandboxes { # Runtimes Sécurisés
  n9: rectangle label="Sandbox Acme"
  n10: rectangle label="Sandbox Beta"
}

client_users.n1.handle(right) -> entry_gateways.n3.handle(left) [label="/eng ou /support"]
client_users.n2.handle(right) -> entry_gateways.n4.handle(left) [label="général"]
entry_gateways.n3.handle(right) -> hermes_profiles.n5.handle(left)
hermes_profiles.n5.handle(right) -> hermes_profiles.n6.handle(left) [label="si /eng"]
hermes_profiles.n5.handle(bottom) -> hermes_profiles.n7.handle(top) [label="si /support"]
entry_gateways.n4.handle(right) -> hermes_profiles.n8.handle(left)
hermes_profiles.n6.handle(right) -> execution_sandboxes.n9.handle(left) [label="exécute"]
hermes_profiles.n7.handle(right) -> execution_sandboxes.n9.handle(left) [label="exécute"]
hermes_profiles.n8.handle(right) -> execution_sandboxes.n10.handle(left) [label="exécute"]

Par Où Commencer

Votre Situation	Commencer Par	Évoluer Vers
Premier client, tests	Option 1	→ Option 2 pour les départements
Un client, 2+ équipes	Option 2	→ Option 4 pour le client 2
3+ clients payants	Option 3	→ Option 4 à mesure que les clients se développent

Comment les Tableaux Kanban Aident-ils les Équipes Multi-Clients ?

Hermes Kanban est un tableau de tâches durable — chaque tâche est une ligne dans SQLite, chaque transfert est une ligne que tout profil peut voir et modifier. Depuis la v0.13.0, le dispatcher s'exécute intégré dans la gateway par défaut.

Utilisez des tableaux séparés par client pour réduire les erreurs de coordination et garder le travail segmenté. Dans Hermes Kanban, les tableaux sont la frontière d'isolation dure à l'intérieur de Kanban, tandis que les locataires ne sont qu'un filtre mou.

task_planner { # Planificateur
  n1: rectangle label="Orchestrateur"
}

shared_board { # Coordination
  n2: rectangle label="kanban.db partagé"
}

specialized_workers { # Travailleurs
  n3: rectangle label="Chercheur A"
  n4: rectangle label="Chercheur B"
  n5: rectangle label="Rédacteur"
}

final_result { # Livrable
  n6: circle label="Livrable"
}

task_planner.n1.handle(right) -> shared_board.n2.handle(left) [label="créer tâches"]
shared_board.n2.handle(right) -> specialized_workers.n3.handle(left) [label="prendre tâche 1"]
shared_board.n2.handle(right) -> specialized_workers.n4.handle(left) [label="prendre tâche 2"]
specialized_workers.n3.handle(right) -> shared_board.n2.handle(right) [label="terminé"]
specialized_workers.n4.handle(right) -> shared_board.n2.handle(right) [label="terminé"]
shared_board.n2.handle(bottom) -> specialized_workers.n5.handle(top) [label="débloquer rédacteur"]
specialized_workers.n5.handle(right) -> final_result.n6.handle(left) [label="publier"]

La commande /kanban fonctionne sur toutes les plateformes gateway — Telegram, Discord, Slack, WhatsApp, Signal, Matrix, Mattermost, email et SMS.

Qu'est-ce qui a Changé dans Hermes Agent v0.13.0 ?

Depuis le 7 mai 2026, la dernière version publique de Hermes Agent est la v0.13.0. Les éléments ci-dessous sont les fonctionnalités les plus pertinentes pour cette configuration dans la documentation et les notes de release actuelles.

Le dispatcher Kanban est intégré dans la gateway par défaut — pas de processus daemon séparé pour la configuration normale.
Plusieurs tableaux Kanban — séparation propre des projets par client ou par projet.
Alias auto de profils — chaque profil devient sa propre commande CLI.
Sécurité de verrouillage de token — les tokens de bot en double déclenchent une erreur claire.
Les skills packagés se synchronisent vers tous les profils lors du hermes update.

Guide Étape par Étape : Intégrer un Nouveau Client

# 1. Profil frais — pas de --clone
hermes profile create client-x

# 2. Restreindre l'espace de travail et sandbox
client-x config set terminal.cwd /var/hermes-clients/client-x
client-x config set terminal.backend docker

# 3. Configurer le token de bot
nano ~/.hermes/profiles/client-x/.env
# TELEGRAM_BOT_TOKEN=789012:ABC-DEF-...

# 4. Désactiver les toolsets packagés dont le client n'a pas besoin
client-x config set agent.disabled_toolsets '["flowzap","creative","media"]'
# Note : les skills packagés se synchronisent automatiquement sur hermes update.
# Les skills personnalisés vont dans ~/.hermes/profiles/client-x/skills/ uniquement si vous les construisez pour ce profil.

# 5. Démarrer la gateway
client-x gateway start

Pour les clients multi-départements, utilisez un profil + routage SOUL.md au lieu de lutter contre le verrouillage de token.

~/.hermes/profiles/beta/SOUL.md
→ "Agent Beta Corp. Préfixe /engineering pour l'accès aux outils.
  Préfixe /support pour la résolution de tickets en lecture seule."

Ce qui Fonctionne vs. Ce qui Casse

Scénario	Verdict
3 clients, 1 département chacun, backend Docker	Fonctionne. Profils + backends sandboxés couvrent l'état Hermes + l'isolation d'exécution.
1 client, 5 départements, token de bot partagé	Verrouillage de token bloque. Utiliser le routage interne ou des bots séparés.
Deux profils, même token	La seconde gateway refuse de démarrer.
Backends différents par client (Docker vs local)	Fonctionne. Définir `terminal.backend` par profil.
Système de fichiers cross-client via backend local	Les profils n'isolent pas le système de fichiers. Utiliser Docker.
Tâche Kanban dans le tableau d'un mauvais client	Des tableaux séparés par client réduisent ce risque car les tableaux sont la frontière d'isolation dure à l'intérieur de Kanban.
Client accède au tableau de bord partagé	Le tableau de bord partagé est réservé aux admins. Kanban est partagé entre les profils sur le même hôte, donc un tableau de bord orienté client devrait s'exécuter sur un runtime Hermes isolé séparé, pas seulement sur un `HERMES_HOME` isolé.
`--clone` du personnel vers un profil client	Risque de fuite de clés API. Créer des profils frais.

L'Essentiel

Hermes Agent peut supporter plusieurs clients sur un seul serveur, mais un déploiement multi-tenant sûr dépend de la manière dont vous configurez l'exécution. Les profils isolent bien l'état Hermes ; Docker, SSH, Modal, Daytona, Vercel Sandbox ou Singularity fournissent les frontières d'exécution plus fortes dont vous avez besoin pour le travail orienté client. Si vous voulez des tableaux de bord orientés clients, utilisez un runtime Hermes isolé séparé par entreprise ; si vous restez sur un hôte partagé, gardez le tableau de bord privé et utilisez les canaux de messagerie pour l'accès client.

Configuration Multi-Client de Hermes Agent : Profils, Sandbox et Kanban pour Plusieurs Clients