Introduction à OpenMOSS : Transformez l'IA en une équipe d'entreprise opérationnelle 24h/24 grâce à la collaboration multi-agents

Difficulté : Débutant | Durée : 30 minutes | Objectif : Comprendre le système de collaboration à quatre rôles d'OpenMOSS et bâtir votre propre équipe d'IA

---

Lecteurs cibles

Vous utilisez déjà OpenClaw et avez expérimenté la puissance d'un agent unique : il peut discuter, coder et exécuter des tâches. Cependant, vous avez probablement remarqué qu'une fois la tâche complexe ou nécessitant plusieurs étapes de collaboration, un agent seul a tendance à se bloquer à une étape précise et à rester "inerte" en attendant votre relance.

OpenMOSS vise à résoudre ce problème. Son concept est simple : ne laissez pas un seul agent tout porter sur ses épaules, mais dotez l'IA d'une structure organisationnelle. Le Planificateur décompose les besoins, l'Exécuteur réalise le travail, le Réviseur assure le contrôle qualité, et le Patrouilleur surveille l'ensemble. Ces quatre rôles s'acquittent de leurs fonctions respectives et fonctionnent de manière autonome via des réveils programmés, formant ainsi une équipe d'entreprise IA en circuit fermé.

OpenMOSS est en soi un middleware ; il ne gère pas les processus métier spécifiques, mais orchestre la collaboration. Quels que soient les « Skills » (compétences) que vous lui configurez, il pourra collaborer automatiquement pour accomplir la tâche.

Cet article s'adresse à :

• Ceux qui utilisent déjà OpenClaw et souhaitent expérimenter la collaboration multi-agents.
• Ceux qui ont besoin d'une IA fonctionnant en continu sans surveillance humaine.
• Ceux qui souhaitent mettre en place des pipelines de production de contenu, de maintenance automatisée, de revue de code, etc.

---

Dépendances et environnement

Dépôt GitHub : https://github.com/uluckyXH/OpenMOSS

---

Structure complète du projet

OpenMOSS/
├── app/                          # Backend FastAPI
│   ├── main.py                   # Entrée : routage, middleware, service statique SPA
│   ├── config.py                 # Chargement de la configuration
│   ├── database.py               # Initialisation BDD (SQLAlchemy)
│   ├── models/                  # Modèles de données (10 tables)
│   ├── routers/                 # Routes API
│   ├── services/                # Couche logique métier
│   └── schemas/                 # Modèles de sérialisation Pydantic
├── webui/                        # Source frontend Vue 3 (à compiler)
├── static/                       # Build frontend (servi directement par le backend)
├── prompts/                      # Modèles de prompts pour les rôles d'agents
│   ├── templates/                # Modèles de base des rôles
│   ├── agents/                   # Exemples de prompts d'agents
│   └── tool/                    # Prompts d'appels d'outils
├── skills/                        # Définition des compétences OpenClaw
│   ├── task-cli.py              # Script d'appel API commun aux compétences
│   ├── task-planner-skill/      # Compétence Planificateur
│   ├── task-executor-skill/      # Compétence Exécuteur
│   ├── task-reviewer-skill/     # Compétence Réviseur
│   ├── task-patrol-skill/       # Compétence Patrouilleur
│   └── dist/                    # Paquets .zip des compétences compilées
├── config.example.yaml            # Modèle de fichier de configuration
├── requirements.txt              # Dépendances Python
├── Dockerfile
└── docker-compose.yml

---

Guide pas à pas

Étape 1 : Cloner le projet et installer les dépendances

# Cloner le projet
git clone https://github.com/uluckyXH/OpenMOSS.git openmoss
cd openmoss

# Installer les dépendances Python
pip install -r requirements.txt

Si votre dépôt ne contient pas de répertoire static/ (frontend non compilé), vous devrez le bâtir :

cd webui
npm install
npm run build

# Copier le résultat du build vers le répertoire static/
rm -rf ../static/*
cp -r dist/* ../static/
cd ..

---

Étape 2 : Configurer config.yaml

Au premier lancement, OpenMOSS générera automatiquement config.yaml à partir de config.example.yaml. Il est conseillé de copier le modèle manuellement avant de le modifier :

cp config.example.yaml config.yaml

Ensuite, éditez config.yaml. Les champs suivants doivent être configurés :

# Mot de passe administrateur (chiffré automatiquement après le premier démarrage)
admin:
  password: "votre-mot-de-passe-securise"

# Jeton d'enregistrement d'agent (requis pour l'inscription, générez une chaîne aléatoire)
agent:
  registration_token: "votre-jeton-aleatoire"
  allow_registration: true

# Répertoire de travail (où les agents stockent leurs livrables)
workspace:
  root: "/home/votre-utilisateur/TaskWork"

# Adresse externe du serveur (nécessaire pour la connexion des agents)
server:
  external_url: "http://votre-ip-serveur:6565"

---

Étape 3 : Lancer le service et suivre l'assistant d'initialisation

python -m uvicorn app.main:app --host 0.0.0.0 --port 6565

Le premier démarrage effectuera automatiquement :

1. La génération de config.yaml (si absent)
2. L'initialisation de la base SQLite (data/tasks.db)
3. Le montage du frontend (si le dossier static/ existe)

Ouvrez votre navigateur sur http://localhost:6565. Vous serez redirigé vers l'assistant pour :

• Définir le mot de passe admin
• Configurer le nom du projet
• Générer le jeton d'enregistrement d'agent
• Configurer optionnellement les canaux de notification

Une fois terminé, les adresses de service sont :

---

Étape 4 : Se connecter à la WebUI et se familiariser avec le backend

Après l'initialisation, connectez-vous avec le compte admin. Vous verrez les pages suivantes :

Au démarrage, la liste des agents est vide. L'étape 5 explique comment les créer.

---

Étape 5 : Créer quatre agents et les enregistrer dans OpenClaw

Les quatre rôles d'OpenMOSS correspondent à des responsabilités distinctes :

Chaque agent est essentiellement une instance OpenClaw. Prenons l'exemple du planificateur (le processus est identique pour les autres).

Méthode 1 : Inscription via WebUI (Recommandé)

1. Sur la page Agent de la WebUI, cliquez sur « Enregistrer un agent ».
2. Remplissez les informations :

Rôle : planner
Nom : OpenMOSS-Planner
Jeton d'enregistrement : (celui défini dans config.yaml)

1. Après soumission, la WebUI renverra :
   • La clé API de l'agent (à conserver précieusement, affichée une seule fois)
   • Les liens de téléchargement de SKILL.md et task-cli.py
   • Le guide de connexion (incluant la commande d'enregistrement)

Méthode 2 : Inscription via API

curl -X POST http://localhost:6565/api/agents/register \
  -H "X-Registration-Token: votre-jeton-enregistrement" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "OpenMOSS-Planner",
    "role": "planner"
  }'

Enregistrez de la même manière les trois autres agents : executor, reviewer, patrol.

---

Étape 6 : Configurer les compétences (Skills) de l'agent

Après l'inscription, chaque agent reçoit deux fichiers clés :

• task-cli.py : Script d'appel API commun.
• SKILL.md : Définition de compétence spécifique au rôle.

Placez-les dans le répertoire de l'agent OpenClaw :

mkdir -p ~/.openclaw/agents/openmoss-planner/skills
curl -o ~/.openclaw/agents/openmoss-planner/skills/task-cli.py http://localhost:6565/skills/task-cli.py
curl -o ~/.openclaw/agents/openmoss-planner/skills/SKILL.md http://localhost:6565/skills/task-planner-skill/SKILL.md

Ensuite, dans la configuration de l'agent OpenClaw, ajoutez le chemin de SKILL.md pour que l'agent sache quelles API appeler.

---

Étape 7 : Configurer le cron pour le réveil automatique

C'est la différence majeure : l'agent n'attend pas votre message, il "badge" au travail à heures fixes.

Dans OpenClaw, configurez les tâches cron pour chaque agent :

• planner (toutes les 30 min) : Vérifier les nouvelles tâches.
• executor (toutes les 15 min) : Récupérer et exécuter les sous-tâches.
• reviewer (toutes les 20 min) : Examiner les livrables en attente.
• patrol (toutes les 10 min) : Inspecter l'état du système.

Le processus est automatisé : l'agent se réveille, appelle l'API OpenMOSS, agit selon son rôle, écrit le résultat et se rendort.

---

Étape 8 : Lancer la première tâche

Dans la WebUI > Gestion des tâches, créez une tâche : Nom : Traduction et publication auto d'actus IA.

Le flux se déclenche :

1. Le Planificateur décompose en modules (Collecte → Traduction → Revue → Publication).
2. L'Exécuteur récupère les sous-tâches, effectue les recherches et traductions, puis soumet.
3. Le Réviseur note le travail. Si c'est validé, la tâche avance ; sinon, l'exécuteur doit recommencer.
4. Le Patrouilleur surveille les délais et les blocages.

---

Étape 9 : Configurer les notifications

Configurez config.yaml pour recevoir des alertes (Lark/Feishu, etc.) lors d'événements clés comme task_completed ou patrol_alert.

---

Dépannage courant

1. Échec d'enregistrement : Vérifiez que le X-Registration-Token correspond exactement à celui du fichier config.
2. L'agent ne se réveille pas : Vérifiez la validité de l'expression cron dans OpenClaw et assurez-vous que le processus OpenClaw est actif.
3. Boucle de rejet : Si le Réviseur rejette sans cesse, clarifiez les critères d'acceptation dans le prompt du Planificateur ou utilisez un modèle LLM plus puissant pour l'Exécuteur.
4. Anomalies d'inventaire : Si deux exécuteurs prennent la même tâche, augmentez l'intervalle cron pour laisser le temps au statut de se mettre à jour.

---

Lecture prolongée / Directions avancées

• Prompts personnalisés : Modifiez les fichiers dans prompts/agents/ pour ajuster la personnalité de vos agents.
• Skill WordPress : Utilisez skills/wordpress-skill/ pour publier automatiquement les articles.
• Système de points : Ajustez la sévérité du Réviseur dans son prompt pour influencer le classement de performance.
• Recherche en ligne : Intégrez le Skill Grok Search pour permettre aux agents de saisir l'actualité du Web en temps réel.