Hiérarchies d’agents IA B2B – n8n + Claude Opus

Un agent IA seul peut gérer une tâche. Une hiérarchie d’agents IA peut gérer un processus métier complet. C’est la différence entre un assistant et une équipe virtuelle autonome. Pour les entreprises B2B, cette distinction est fondamentale : vos workflows de vente, de support ou de reporting impliquent trop de sous-tâches, de sources de données et de règles métier pour qu’un seul agent puisse tout gérer efficacement.

Dans cet article, nous allons vous montrer comment construire des hiérarchies d’agents IA pour vos workflows B2B en combinant n8n (l’orchestrateur de workflows) et Claude Opus 4 (le LLM de raisonnement).

Pourquoi des hiérarchies multi-agents ?

La promesse des agents IA autonomes se heurte rapidement à deux limites fondamentales :

• La fenêtre de contexte : même avec 200K tokens, un seul agent ne peut pas gérer toute la complexité d’un workflow B2B étendu
• La spécialisation : un agent généraliste fait tout «à peu près bien». Des agents spécialisés font chacun leur tâche très bien

La solution multi-agents résout ces deux problèmes : un agent orchestrateur comprend le workflow global et délègue à des agents spécialisés qui ont chacun leur domaine d’expertise, leurs outils et leur contexte.

Architecture de référence : l’orchestre multi-agents

L’agent orchestrateur (Claude Opus 4)

L’orchestrateur est le chef d’orchestre. Son rôle :

• Comprendre la tâche globale et la décomposer en sous-tâches
• Décider quel agent spécialisé doit traiter chaque sous-tâche
• Passer le contexte pertinent à chaque agent
• Agréger les résultats et produire la sortie finale
• Gérer les erreurs et les cas limites

Claude Opus 4 est particulièrement adapté à ce rôle grâce à ses capacités de raisonnement long et sa fiabilité dans le suivi des instructions complexes.

Les agents spécialisés

Chaque agent spécialisé est conçu pour une tâche précise avec :

• Un prompt système optimisé pour sa spécialité
• Un accès limité aux outils dont il a besoin (et seulement ceux-là)
• Un modèle adapté à sa tâche (pas forcément Opus – Haiku suffit souvent)

Implémentation avec n8n

Structure du workflow n8n

Dans n8n, votre hiérarchie d’agents se traduit par un workflow en étoile :

1. Nœud trigger : webhook, schedule ou événement CRM
2. Nœud orchestrateur : appel Claude Opus avec le prompt de coordination
3. Nœuds agents spécialisés : branches parallèles ou séquentielles selon les dépendances
4. Nœud agrégateur : consolidation des résultats
5. Nœud action : mise à jour CRM, envoi email, création ticket, etc.

Configuration de l’agent orchestrateur

Voici le prompt système type pour votre orchestrateur :

Tu es un orchestrateur d'agents IA pour les workflows B2B de [Entreprise].
Tu reçois une tâche et tu dois la décomposer en sous-tâches que tu délègues aux agents spécialisés suivants :

- AGENT_RECHERCHE : enrichit les informations sur une entreprise ou un contact
- AGENT_QUALIFICATION : évalue le fit ICP et score le lead
- AGENT_REDACTION : génère des messages personnalisés
- AGENT_CRM : lit et met à jour le CRM

Pour chaque sous-tâche, indique :
1. L'agent à utiliser
2. Les inputs à lui fournir
3. Les outputs attendus
4. Les dépendances avec les autres sous-tâches

Réponds en JSON structuré.

Cas d’usage 1 : Qualification automatique de leads

Le workflow

Un nouveau lead entre dans votre CRM (HubSpot, Salesforce, Pipedrive). Le workflow multi-agents se déclenche automatiquement :

1. Agent Recherche : enrichit les données de l’entreprise (Clearbit, LinkedIn, site web)
2. Agent Analyse : analyse le site web, les offres d’emploi et les signaux d’intention
3. Agent Qualification : évalue le fit ICP selon vos critères (taille, secteur, stack tech, budget estimé)
4. Agent Orchestrateur : consolide les scores et prend une décision (MQL, SQL, disqualifié)
5. Agent CRM : met à jour le deal avec le score, les notes et les prochaines actions recommandées

Implémentation n8n

// Nœud Agent Orchestrateur (HTTP Request vers API Claude)
{
  "model": "claude-opus-4-6",
  "max_tokens": 2000,
  "system": "Tu es l'orchestrateur de qualification leads...",
  "messages": [
    {
      "role": "user",
      "content": "Qualifie ce lead : {{$json.company_name}}, {{$json.email}}, industrie: {{$json.industry}}"
    }
  ]
}

Résultats observés

Les entreprises B2B qui ont déployé ce workflow rapportent :

• Réduction de 70% du temps de qualification manuelle
• Amélioration de 30% du taux de conversion MQL→SQL grâce à une meilleure priorisation
• Données CRM enrichies à 100% vs 40-60% avec saisie manuelle

Cas d’usage 2 : Support client intelligent

Le workflow

Un ticket de support arrive. L’hiérarchie d’agents prend en charge :

1. Agent Classification : catégorise le ticket (bug, question, feature request, facturation)
2. Agent Contexte : récupère l’historique du client dans le CRM et les tickets précédents
3. Agent Base de connaissance : cherche une réponse dans votre documentation (RAG)
4. Agent Rédaction : génère une réponse personnalisée et adaptée au profil du client
5. Agent Escalade : décide si une intervention humaine est nécessaire et priorise

Le handoff humain

Un point critique dans les hiérarchies d’agents B2B : définir les conditions du handoff humain. Votre orchestrateur doit savoir quand escalader :

• Client stratégique ou grand compte
• Ticket impliquant des données sensibles ou financières
• Situation de crise ou urgence P0/P1
• Demande hors politique standard

Cas d’usage 3 : Reporting automatique

Le workflow hebdomadaire

Chaque lundi matin, votre hiérarchie d’agents génère automatiquement le rapport commercial :

1. Agent Data : extrait les KPIs de la semaine (CRM, analytics, finance)
2. Agent Analyse : compare avec N-1 et les objectifs, identifie les tendances
3. Agent Narrative : génère le commentaire managérial avec les insights clés
4. Agent Format : met en forme le rapport (PDF, email, slides)
5. Agent Distribution : envoie au bon comité selon le type de rapport

Bonnes pratiques pour vos hiérarchies d’agents

• Testez chaque agent individuellement avant de les connecter en hiérarchie
• Loggez tout : chaque décision de l’orchestrateur doit être tracée pour le débogage
• Définissez des timeouts : un agent qui ne répond pas ne doit pas bloquer tout le pipeline
• Commencez simple : 2-3 agents coordonnés donnent déjà d’excellents résultats avant de passer à des architectures plus complexes
• Monitorer les coûts : Claude Opus coûte plus cher – réservez-le à l’orchestrateur et utilisez Haiku ou Sonnet pour les agents spécialisés

Conclusion

Les hiérarchies d’agents IA représentent le futur de l’automatisation B2B. Avec n8n comme couche d’orchestration et Claude Opus comme cerveau décisionnel, vous pouvez automatiser des workflows entiers qui requéraient jusqu’ici plusieurs collaborateurs. La clé du succès : commencer par un cas d’usage à fort impact, bien définir les rôles de chaque agent, et itérer en mesurant les résultats.

Prêt à construire votre première hiérarchie d’agents IA B2B ? Contactez Digitalizor – nous concevons et déployons des architectures multi-agents sur mesure pour vos processus métier.

🧠 Architecture hiérarchique d’agents IA B2B

📐 Les 4 types d’architectures multi-agents

⚖️ Comparatif n8n vs LangGraph vs CrewAI

⚙️ Code n8n JSON : Workflow qualification leads avec handoff entre agents

{
  "name": "Agent Qualification Leads B2B",
  "nodes": [
    {
      "name": "Trigger - Nouveau lead",
      "type": "n8n-nodes-base.webhook",
      "position": [100, 300],
      "parameters": {
        "path": "new-lead",
        "method": "POST"
      }
    },
    {
      "name": "Agent Research - Enrichissement",
      "type": "@n8n/n8n-nodes-langchain.agent",
      "position": [350, 300],
      "parameters": {
        "systemMessage": "Tu es un agent de recherche B2B. Analyse le lead fourni et enrichis-le avec : taille entreprise, secteur, signaux d'achat recents. Reponds en JSON structure.",
        "model": "claude-sonnet-4-6",
        "tools": ["httpRequest", "serperSearch"]
      }
    },
    {
      "name": "Scoring - Qualification",
      "type": "n8n-nodes-base.code",
      "position": [600, 300],
      "parameters": {
        "jsCode": "const lead = $input.first().json;\nconst score = (lead.company_size > 100 ? 30 : 10) + (lead.has_budget ? 40 : 0) + (lead.buying_signal ? 30 : 0);\nreturn [{ json: { ...lead, score, qualified: score >= 60 } }];"
      }
    },
    {
      "name": "Routage - Hot/Cold",
      "type": "n8n-nodes-base.if",
      "position": [850, 300],
      "parameters": {
        "conditions": {
          "number": [{ "value1": "={{$json.score}}", "operation": "gte", "value2": 60 }]
        }
      }
    },
    {
      "name": "Agent CRM - Push HubSpot",
      "type": "@n8n/n8n-nodes-langchain.agent",
      "position": [1100, 200],
      "parameters": {
        "systemMessage": "Tu es un agent CRM. Cree le contact dans HubSpot avec les donnees enrichies. Assigne au bon commercial selon le secteur.",
        "model": "claude-haiku-4-5-20251001"
      }
    },
    {
      "name": "Nurturing - Sequence email",
      "type": "n8n-nodes-base.emailSend",
      "position": [1100, 400],
      "parameters": {
        "toEmail": "={{$json.email}}",
        "subject": "Ressources pour votre projet IA"
      }
    }
  ]
}

🐍 Code Python : Agents hiérarchiques Claude avec tools

"""
Architecture multi-agents hierarchique avec Claude - B2B Lead Qualification
"""
import anthropic
import json
from typing import Any

client = anthropic.Anthropic(api_key="sk-ant-...")

# ── Outils disponibles pour les agents ───────────────────────────────────
RESEARCH_TOOLS = [
    {
        "name": "search_company_info",
        "description": "Recherche des informations sur une entreprise (taille, secteur, actualites)",
        "input_schema": {
            "type": "object",
            "properties": {
                "company_name": {"type": "string", "description": "Nom de l'entreprise"},
                "domain": {"type": "string", "description": "Domaine web de l'entreprise"}
            },
            "required": ["company_name"]
        }
    },
    {
        "name": "check_buying_signals",
        "description": "Detecte les signaux d'achat recents (levees de fonds, recrutements IT, appels d'offres)",
        "input_schema": {
            "type": "object",
            "properties": {
                "company_name": {"type": "string"},
                "lookback_days": {"type": "integer", "default": 90}
            },
            "required": ["company_name"]
        }
    }
]

CRM_TOOLS = [
    {
        "name": "create_hubspot_contact",
        "description": "Cree ou met a jour un contact dans HubSpot CRM",
        "input_schema": {
            "type": "object",
            "properties": {
                "email": {"type": "string"},
                "company": {"type": "string"},
                "score": {"type": "integer"},
                "owner_id": {"type": "string"}
            },
            "required": ["email", "company", "score"]
        }
    }
]

# ── Agent Research ────────────────────────────────────────────────────────
def agent_research(lead: dict) -> dict:
    """Agent specialise dans l'enrichissement de leads B2B."""
    messages = [
        {
            "role": "user",
            "content": f"Enrichis ce lead B2B et evalue son potentiel : {json.dumps(lead, ensure_ascii=False)}"
        }
    ]
    response = client.messages.create(
        model="claude-sonnet-4-6",
        max_tokens=1000,
        system="Tu es un agent de recherche B2B expert. Utilise les outils disponibles pour enrichir le lead. Retourne un JSON avec : company_size, sector, buying_signals (liste), estimated_budget.",
        tools=RESEARCH_TOOLS,
        messages=messages
    )
    # Simule le retour de l'outil (en prod : appel API reel)
    enriched = {**lead, "company_size": 250, "sector": "SaaS",
                "buying_signals": ["recrutement VP Sales", "levee Serie A"], "estimated_budget": 50000}
    return enriched

# ── Orchestrateur ─────────────────────────────────────────────────────────
def orchestrator(lead: dict) -> dict:
    """Orchestrateur principal qui coordonne les agents specialises."""
    # Etape 1 : Enrichissement
    print(f"[Orchestrateur] Traitement du lead : {lead.get('email', 'N/A')}")
    enriched_lead = agent_research(lead)

    # Etape 2 : Scoring via Claude
    scoring_prompt = f"""
    Sur la base de ces donnees, calcule un score de qualification de 0 a 100 :
    {json.dumps(enriched_lead, ensure_ascii=False, indent=2)}

    Criteres : taille entreprise (30pts), signaux achat (40pts), budget estime (30pts).
    Reponds en JSON : {{"score": X, "reasoning": "...", "next_action": "hot_lead|nurturing|disqualify"}}
    """
    score_response = client.messages.create(
        model="claude-sonnet-4-6",
        max_tokens=300,
        messages=[{"role": "user", "content": scoring_prompt}]
    )
    try:
        scoring = json.loads(score_response.content[0].text)
    except json.JSONDecodeError:
        scoring = {"score": 50, "reasoning": "Parsing error", "next_action": "nurturing"}

    result = {**enriched_lead, **scoring}
    print(f"[Orchestrateur] Score : {scoring['score']} | Action : {scoring['next_action']}")

    # Etape 3 : Handoff vers agent CRM si lead chaud
    if scoring.get("next_action") == "hot_lead":
        print("[Orchestrateur] Handoff -> Agent CRM")
        # agent_crm(result)  # Appel agent CRM (non implémenté ici)

    return result

# ── Execution ─────────────────────────────────────────────────────────────
if __name__ == "__main__":
    lead_test = {
        "email": "cto@techstartup.fr",
        "first_name": "Marie",
        "company": "TechStartup SAS",
        "source": "linkedin"
    }
    result = orchestrator(lead_test)
    print("\nResultat final :", json.dumps(result, ensure_ascii=False, indent=2))