Construire un Système de Sous-Agents Experts pour Claude Code avec MCP

Claude Code est un excellent assistant de développement. Mais même le meilleur généraliste a ses limites. Quand je fais une code review, j’ai besoin d’un regard spécialisé sécurité. Quand je design une architecture, j’ai besoin d’un expert en trade-offs systèmes. Quand je planifie une feature, j’ai besoin d’un analyste de scope.

C’est le problème que résout GLM Delegator : un système de 5 agents experts spécialisés, intégrés dans Claude Code via le protocole MCP.

Le concept : délégation intelligente

Au lieu d’un seul LLM qui fait tout, GLM Delegator propose 5 experts avec des rôles distincts :

Expert	Rôle	Cas d’usage
Architect	Design système, trade-offs, debugging complexe	Décisions d’architecture, choix de patterns
Plan Reviewer	Validation de plans avant exécution	Vérifier qu’un plan d’implémentation est cohérent
Scope Analyst	Détection d’ambiguïtés	Identifier les zones floues dans un cahier des charges
Code Reviewer	Bugs, qualité, patterns	Review de code multilingue (EN/FR/CN)
Security Analyst	Vulnérabilités, threat modeling	Audit OWASP, analyse de surface d’attaque

Chaque expert a un prompt système spécialisé, des heuristiques propres, et un format de sortie adapté à son domaine.

Architecture technique : MCP Server

Le projet est un serveur MCP (Model Context Protocol) en Python qui expose les 5 experts comme des tools disponibles dans Claude Code.

# Chaque expert est un tool MCP
@server.tool("glm_architect")
async def architect(task: str, files: list[str], mode: str = "advisory"):
    """System design, tradeoffs, complex debugging"""
    return await delegate_to_expert("architect", task, files, mode)

@server.tool("glm_security_analyst")
async def security(task: str, files: list[str], mode: str = "advisory"):
    """Vulnerability detection, threat modeling"""
    return await delegate_to_expert("security", task, files, mode)

Claude Code découvre ces tools automatiquement via la config MCP :

{
  "mcpServers": {
    "glm-experts": {
      "type": "stdio",
      "command": "python3",
      "args": ["glm_mcp_server.py", "--provider", "anthropic", "--model", "claude-sonnet-4-5-20250929"]
    }
  }
}

Deux modes de fonctionnement

• Advisory : l’expert analyse et recommande, sans toucher au code
• Implementation : l’expert propose des modifications concrètes

Le mode advisory est le défaut — on veut un avis d’expert, pas un agent autonome qui modifie le code sans validation.

Multi-provider : pas de vendor lock-in

La particularité de GLM Delegator : il fonctionne avec n’importe quel fournisseur LLM compatible OpenAI ou Anthropic :

• Anthropic Claude (Sonnet, Opus, Haiku)
• OpenAI GPT
• GLM-4.7 (via Z.AI)
• Ollama (modèles locaux)
• Groq, DeepInfra, TogetherAI
• vLLM, LM Studio

Chaque expert peut utiliser un provider différent. Vous pouvez avoir l’Architect sur Claude Opus pour les décisions critiques, et le Code Reviewer sur un modèle local pour la confidentialité.

Cas d’usage en pratique

Architecture review

"Demande à l'architecte d'évaluer ma structure hexagonale
pour le module de paiement. Fichiers : src/Domain/Payment/,
src/Infrastructure/Stripe/"

L’expert Architect analyse la structure, vérifie la direction des dépendances, et identifie les couplages. Le résultat est un rapport structuré avec des recommandations priorisées.

Ce type de review complète le travail de réflexion sur l’architecture logicielle pour applications web modernes que je fais en amont.

Security audit

"Fais auditer par l'analyste sécurité les endpoints d'auth
dans src/Controller/AuthController.php"

L’expert Security vérifie les vulnérabilités OWASP : injection, XSS, authentification faible, exposition de données sensibles. Le rapport classe les findings par sévérité (critique/haute/moyenne/basse).

Scope analysis avant sprint

"Analyse le scope de cette user story :
'En tant qu'admin, je veux pouvoir gérer les permissions des équipes'.
Identifie les ambiguïtés et les questions à poser au PO."

Le Scope Analyst décortique la story, identifie les zones floues (“gérer” veut dire quoi exactement ? CRUD complet ? Héritage de permissions ?), et génère une liste de questions structurées.

Cette approche s’intègre parfaitement dans une démarche de Product Management pour développeurs — clarifier le scope avant de coder.

Retour d’expérience

Ce qui fonctionne

• Le routing automatique : Claude Code choisit le bon expert selon la tâche, sans intervention manuelle
• Le mode advisory : avoir un second avis sans risque de modification non désirée
• Le multi-provider : pouvoir tester différents modèles pour chaque rôle d’expert

Ce qui a demandé de l’itération

• Les prompts systèmes : calibrer le niveau de détail des réponses (trop court = inutile, trop long = noise)
• La gestion du contexte : passer les bons fichiers à l’expert sans surcharger son contexte
• Le format de sortie : structurer les rapports pour qu’ils soient actionnables, pas juste informatifs

Le vrai gain

Le gain n’est pas de remplacer la review humaine. C’est d’automatiser le screening initial. L’expert Security attrape les vulnérabilités évidentes avant que le reviewer humain ne les cherche. L’Architect valide la cohérence structurelle avant la discussion d’équipe. Le temps humain se concentre sur les décisions qui nécessitent du jugement.

C’est exactement la philosophie que je décris dans mon article sur l’IA dans le workflow développeur : l’IA pour le mécanique, l’humain pour le jugement.

En résumé

GLM Delegator transforme Claude Code en une équipe de 5 experts spécialisés via le protocole MCP :

• 5 rôles : Architect, Plan Reviewer, Scope Analyst, Code Reviewer, Security Analyst
• Multi-provider : Anthropic, OpenAI, Ollama, Groq, et plus
• Deux modes : Advisory (recommandations) et Implementation (modifications)
• Intégration native : découverte automatique via la config MCP

Le projet est open source : github.com/MakFly/glm-delegator.