Lorsque mon collègue a commencé à utiliser mon instance OpenClaw, j’ai découvert que le multi-utilisateur n’était pas qu’une case à cocher dans la configuration. C’était une refonte de la façon dont l’agent appréhendait le contexte, les autorisations et la vie privée.
Le moment où j’ai réalisé cela : mon collègue a demandé à l’agent de se renseigner sur « le projet », et l’agent a affiché mon projet personnel — pas le projet de l’équipe auquel il pensait. L’agent avait un seul contexte, une seule mémoire, et aucune notion que différents utilisateurs pouvaient avoir des projets différents avec le même nom.
Configurer correctement le multi-utilisateur m’a pris trois essais. Voici ce que j’ai appris.
Essai 1 : Tout partagé
Ma première approche : nous utilisons tous les deux le même agent avec la même configuration. Mise en place facile. Horrible en pratique.
Problèmes :
– L’agent a confondu nos contextes (« Vous avez mentionné vouloir de la pizza pour le dîner » — c’était mon collègue, pas moi)
– Les autorisations étaient identiques (mon collègue pouvait voir mes automatisations personnelles et vice versa)
– La mémoire était partagée (tout ce qu’une personne disait à l’agent, l’autre pouvait y accéder)
– Les tâches cron s’exécutaient pour nous deux, sans égard à la pertinence
Cela fonctionne si vous n’avez aucune exigence de confidentialité et des cas d’utilisation identiques. En pratique, personne n’a zéro exigence de confidentialité.
Essai 2 : Instances séparées
Ma deuxième approche : chaque utilisateur dispose de sa propre instance OpenClaw fonctionnant sur le même serveur. Isolation complète. Pas de contexte partagé.
Problèmes :
– Double utilisation des ressources (deux processus, deux ensembles de mémoire)
– Pas de connaissance partagée (nous devions informer les deux agents des processus d’équipe séparément)
– Configuration dupliquée (toute modification devait être effectuée deux fois)
– Compétences installées deux fois, mises à jour deux fois, maintenues deux fois
Cela fonctionne si les utilisateurs sont complètement indépendants. Mais nous partageons une équipe, travaillons sur les mêmes projets, et avons besoin d’un certain niveau de contexte partagé.
Essai 3 : Ce qui fonctionne réellement
La solution : une instance avec des sessions à portée utilisateur et une mémoire partagée mais séparée.
Sessions utilisateur. Chaque utilisateur a sa propre session avec son propre historique de conversation et son contexte. Lorsque j’envoie un message à l’agent, il charge mon contexte. Lorsque mon collègue lui envoie un message, il charge leur contexte. Pas de contamination croisée.
Mémoire à portée. Trois portées de mémoire :
– Portée personnelle : visible uniquement par l’utilisateur propriétaire (préférences, projets personnels, notes privées)
– Portée d’équipe : visible par tous (processus d’équipe, détails de projet partagés, décisions de groupe)
– Portée globale : informations au niveau du système (adresses du serveur, configurations des outils)
Lorsque je parle à l’agent de mon projet personnel, cela va dans ma portée personnelle. Lorsque j’en parle du processus de déploiement de l’équipe, cela va dans la portée d’équipe.
Permissions basées sur les rôles. Je suis l’administrateur — je peux configurer le système, gérer les compétences, et accéder à toutes les portées. Mon collègue est un utilisateur standard — il peut utiliser l’agent et gérer sa propre portée personnelle mais ne peut pas changer la configuration du système.
Mise en place
Étape 1 : Configurer l’authentification utilisateur. Chaque plateforme de messagerie a sa propre identification utilisateur. Discord utilise des identifiants utilisateurs, Slack utilise des identifiants de membres, Telegram utilise des identifiants utilisateurs. OpenClaw les associe à des identités internes.
Étape 2 : Configurer l’isolement des sessions. Configurer OpenClaw pour maintenir des sessions séparées par utilisateur. Chaque session a son propre historique de conversation et sa propre fenêtre de contexte.
Étape 3 : Configurer les portées de mémoire. Définir quelles portées existent (personnelle, équipe, globale) et la portée par défaut pour les nouvelles mémoires. Je mets par défaut la portée personnelle — tout est privé sauf s’il est explicitement partagé.
Étape 4 : Définir les permissions. Définir ce que chaque rôle utilisateur peut faire. Utilisateurs standards : interagir avec l’agent, gérer la mémoire personnelle, utiliser des compétences approuvées. Administrateurs : tout plus la configuration du système et l’accès à toutes les portées.
Les pièges
Tâches cron partagées. Une tâche cron qui publie un briefing matinal — doit-elle s’exécuter par utilisateur ou une seule fois pour tout le monde ? La réponse dépend de la tâche. Les briefings matinals sont personnels (calendriers différents, priorités différentes). Les vérifications de la santé du serveur sont partagées (mêmes serveurs pour tous). Configurez chaque tâche avec la portée appropriée.
Permissions des compétences. Certaines compétences sont appropriées pour tout le monde (recherche sur le web, résumé). Certaines sont réservées aux administrateurs (gestion de serveur, configuration du système). Examinez les capacités de chaque compétence et assignez-la au niveau de permission approprié.
Conflits de mémoire. Deux utilisateurs pourraient enregistrer des informations contradictoires dans la portée d’équipe. « Nous utilisons PostgreSQL » et « Nous migrons vers MySQL. » L’agent ne réconcilie pas automatiquement cela — il enregistre les deux et peut faire ressortir l’un ou l’autre. Un examen régulier de la mémoire détecte ces conflits avant qu’ils ne causent de la confusion.
Attribution des coûts. Avec plusieurs utilisateurs partageant une clé API, le suivi des coûts individuels devient important. Sans cela, l’utilisation intensive d’un utilisateur est subventionnée par le budget des autres. J’ai ajouté un suivi des coûts par utilisateur à mon tableau de bord de surveillance.
Considérations sur l’échelle
Cette configuration fonctionne bien pour 2 à 5 utilisateurs. À cette échelle, la gestion manuelle de la mémoire est pratique, la mise en place des permissions est gérable, et une seule instance OpenClaw prend en charge la charge.
Pour des équipes plus grandes (10+ utilisateurs), vous souhaiterez : une gestion automatisée des portées de mémoire (au lieu de manuelle), un contrôle d’accès granulaire basé sur les rôles, un équilibrage de charge entre plusieurs instances, et un véritable tableau de bord administrateur pour la gestion des utilisateurs.
Je n’ai pas eu besoin de monter en échelle au-delà de 5 utilisateurs, donc je ne peux pas parler des détails des déploiements plus importants. Mais l’architecture de base (sessions isolées, mémoire à portée, permissions basées sur les rôles) devrait pouvoir s’adapter si l’infrastructure le permet.
🕒 Published: