Que fait AgentHub — Collaboration multi-agent ?
Lancez N agents IA en parallèle qui concourent sur la même tâche. Chaque agent travaille dans un worktree git isolé. Le coordinateur évalue les résultats et fusionne le gagnant.
Commandes slash
| Commande | Description |
|---|---|
/hub:init | Crée une nouvelle session de collaboration — tâche, nombre d'agents, critères d'évaluation |
/hub:spawn | Lance N sous-agents en parallèle dans des worktrees isolés |
/hub:status | Affiche l'état du DAG, la progression des agents, l'état des branches |
/hub:eval | Classe les résultats des agents par métrique ou juge LLM |
/hub:merge | Fusionne la branche gagnante, archive les perdantes |
/hub:board | Lit/écrit le tableau de messages des agents |
/hub:run | Cycle de vie complet : init → baseline → spawn → eval → merge |
Modèles d'agents
Lors du lancement avec --template, les agents suivent un modèle d'itération prédéfini :
| Modèle | Motif | Cas d'utilisation |
|---|---|---|
optimizer | Éditer → évaluer → garder/abandonner → répéter x10 | Performance, latence, taille |
refactorer | Restructurer → tester → itérer jusqu'au vert | Qualité du code, dette technique |
test-writer | Écrire des tests → mesurer la couverture → répéter | Lacunes de couverture de tests |
bug-fixer | Reproduire → diagnostiquer → corriger → vérifier | Approches de correction de bugs |
Les modèles sont définis dans references/agent-templates.md.
Quand cette compétence s'active
Phrases déclencheurs :
- "essaie plusieurs approches"
- "fais concourir des agents"
- "optimisation parallèle"
- "lance N agents"
- "compare différentes solutions"
- "fan-out" ou "tournoi"
- "génère des variantes de contenu"
- "compare différents brouillons"
- "test A/B de copie"
- "explore plusieurs stratégies"
Protocole du coordinateur
La session principale Claude Code est le coordinateur. Elle suit ce cycle de vie :
INIT → DISPATCH → MONITOR → EVALUATE → MERGE
1. Init
Exécutez /hub:init pour créer une session. Cela génère :
.agenthub/sessions/{session-id}/config.yaml— configuration de la tâche.agenthub/sessions/{session-id}/state.json— machine à états.agenthub/board/— canaux du tableau de messages
2. Dispatch
Exécutez /hub:spawn pour lancer les agents. Pour chaque agent 1..N :
- Publie l'affectation de la tâche dans
.agenthub/board/dispatch/ - Lance via l'outil Agent avec
isolation: "worktree" - Tous les agents sont lancés dans un seul message (en parallèle)
3. Monitor
Exécutez /hub:status pour vérifier la progression :
dag_analyzer.py --status --session {id}affiche l'état des branches- Le canal
progress/du tableau contient les mises à jour des agents
4. Evaluate
Exécutez /hub:eval pour classer les résultats :
- Mode métrique : exécute la commande d'évaluation dans chaque worktree, analyse le résultat numérique
- Mode juge : lit les diffs, le coordinateur classe par qualité
- Hybride : métrique d'abord, juge LLM pour les égalités
5. Merge
Exécutez /hub:merge pour finaliser :
git merge --no-ffdu gagnant dans la branche de base- Tague les perdants :
git tag hub/archive/{session}/agent-{i} - Nettoie les worktrees
- Publie le résumé de fusion sur le tableau
Protocole de l'agent
Chaque sous-agent reçoit ce modèle de prompt :
Vous êtes l'agent-{i} de la session hub {session-id}.
Votre tâche : {description de la tâche}
Instructions :
1. Lisez votre affectation dans .agenthub/board/dispatch/{seq}-agent-{i}.md
2. Travaillez dans votre worktree — effectuez des modifications, exécutez des tests, itérez
3. Validez toutes les modifications avec des messages descriptifs
4. Écrivez votre résumé de résultat dans .agenthub/board/results/agent-{i}-result.md
5. Quittez lorsque vous avez terminé
Les agents ne VOIENT PAS le travail des autres. Ils ne communiquent PAS entre eux. Ils écrivent uniquement sur le tableau pour que le coordinateur puisse lire.
Modèle DAG
Nommage des branches
hub/{session-id}/agent-{N}/attempt-{M}
- ID de session : basé sur l'horodatage (
AAAA MM JJ-HHMMSS) - Agent N : séquentiel (1 à nombre-d-agents)
- Tentative M : s'incrémente en cas de nouvelle tentative (généralement 1)
Détection de frontière
Frontière = pointes de branche sans branches enfants. Équivalent à la requête "feuilles" d'AgentHub.
python scripts/dag_analyzer.py --frontier --session {id}
Immutabilité
Le DAG est en ajout seul :
- Ne jamais rebaser ou forcer la poussée des branches d'agents
- Ne jamais supprimer de commits (seulement les références de branche après archivage)
- Chaque approche est préservée via des tags git
Tableau de messages
Emplacement : .agenthub/board/
Canaux
| Canal | Écrivain | Lecteur | Objectif |
|---|---|---|---|
dispatch/ | Coordinateur | Agents | Affectations des tâches |
progress/ | Agents | Coordinateur | Mises à jour de statut |
results/ | Agents + Coordinateur | Tous | Résultats finaux + résumé de fusion |
Format de publication
---
author: agent-1
timestamp: 2026-03-17T14:30:22Z
channel: results
parent: null
---
## Résumé du résultat
- **Approche** : Remplacement du tri O(n²) par une table de hachage
- **Fichiers modifiés** : 3
- **Métrique** : 142ms (référence : 180ms, delta : -38ms)
- **Confiance** : Élevée — tous les tests passent
Règles du tableau
- Ajout seul : ne jamais modifier ou supprimer de publications
- Noms de fichiers uniques :
{seq:03d}-{author}-{timestamp}.md - Frontmatter YAML obligatoire sur toutes les publications
Modes d'évaluation
Basé sur une métrique
Idéal pour : benchmarks, taux de réussite des tests, tailles de fichiers, temps de réponse.
python scripts/result_ranker.py --session {id} \
--eval-cmd "pytest bench.py --json" \
--metric p50_ms --direction lower
Le classeur exécute la commande d'évaluation dans le répertoire du worktree de chaque agent et analyse la métrique depuis la sortie standard.
Juge LLM
Idéal pour : qualité du code, lisibilité, décisions architecturales.
Le coordinateur lit le diff de chaque agent (git diff base...agent-branch) et classe selon :
- Exactitude (la tâche est-elle résolue ?)
- Simplicité (moins de lignes modifiées, préféré)
- Qualité (exécution propre, bonne structure)
Hybride
Exécutez d'abord la métrique. Si les meilleurs agents sont à moins de 10 % les uns des autres, utilisez le juge LLM pour départager.
Cycle de vie de la session
init → running → evaluating → merged
→ archived (si aucun gagnant)
Transitions d'état gérées par session_manager.py :
| De | Vers | Déclencheur |
|---|---|---|
init | running | /hub:spawn terminé |
running | evaluating | Tous les agents sont de retour |
evaluating | merged | /hub:merge terminé |
evaluating | archived | Aucun gagnant / tous ont échoué |
Déclencheurs proactifs
Le coordinateur doit agir quand :
| Signal | Action |
|---|---|
| Tous les agents ont planté | Publier un résumé d'échec, suggérer une nouvelle tentative avec des contraintes différentes |
| Aucune amélioration par rapport à la référence | Archiver la session, suggérer des approches différentes |
| Worktrees orphelins détectés | Exécuter session_manager.py --cleanup {id} |
Session bloquée dans running | Vérifier le tableau pour la progression, envisager un délai d'attente |
Installation
# Copier dans votre répertoire de compétences Claude Code
cp -r engineering/agenthub ~/.claude/skills/agenthub
# Ou installer via ClawHub
clawhub install agenthub
Scripts
| Script | Objectif |
|---|---|
hub_init.py | Initialiser la structure .agenthub/ et la session |
dag_analyzer.py | Détection de frontière, graphe DAG, statut des branches |
board_manager.py | CRUD du tableau de messages (canaux, publications, fils) |
result_ranker.py | Classer les agents par métrique ou qualité du diff |
session_manager.py | Machine à états de session et nettoyage |
Compétences associées
- autoresearch-agent — Boucle d'optimisation à agent unique (utilisez AgentHub quand vous voulez N agents en compétition)
- self-improving-agent — Agent auto-modificateur (utilisez AgentHub quand vous voulez une compétition externe)
- git-worktree-manager — Utilitaires git worktree (AgentHub utilise les worktrees en interne)