Design Pattern Agentique Routing Pattern (Routeur)

ParPhil MAJ

Modèle de Routage : Architecture Intelligente pour Agents Spécialisés

Le Routage remplace un agent IA généraliste par un système de classification intelligente qui analyse chaque requête et l’achemine vers l’agent spécialisé le plus adapté. Architecture « Diviser et Conquérir » pour optimiser coût, vitesse et précision.

Voir la table des matières complète

1. Le Concept en Une Phrase

Au lieu d’avoir un agent qui fait tout, crée un router qui décide intelligemment quel agent expert doit traiter la requête.

Fonctionnement

[Requête] ↓ [Router : analyse l’intention] ↓ [Décision : quel agent ?] ↓ ┌─────┬─────┬─────┐ ↓ ↓ ↓ ↓ [Agent A] [Agent B] [Agent C] [Escalation] ↓ ↓ ↓ ↓ [Résultat spécialisé]

🎯 Principe

Spécialisation : Chaque agent maîtrise un domaine précis avec ses propres outils et contexte

⚡ Bénéfice

Efficacité : 70% de requêtes simples → modèle léger (50ms, bon marché). 30% complexes → modèle puissant

2. Quand Utiliser le Routage

✅ Cas d’Usage Idéaux

SituationPourquoi le Routage Fonctionne
Requêtes hétérogènesTypes d’actions différentes qui requièrent des outils différents
Complexité variable70%+ de requêtes sont simples, 30% nécessitent un modèle puissant
Outils mutuellement exclusifsBase de données OU Email OU API externe → pas besoin de tout charger
Volume élevé10 000+ requêtes/mois pour rentabiliser l’architecture
Isolation nécessaireContextes qui ne doivent pas se mélanger (sécurité, confidentialité)

❌ Quand NE PAS Utiliser

Anti-PatternPourquoi Éviter
Distribution déséquilibréeSi 95% des requêtes vont au même agent → le router ajoute de la latence inutile
Catégories ambiguësSi le router hésite constamment → erreurs coûteuses, escalations fréquentes
Faible volumeMoins de 5 000 requêtes/mois → ROI négatif, complexité non justifiée
Contexte partagé requisSi tous les agents ont besoin du même contexte → pas d’économie, isolation impossible
Test Simple : Si tu peux classifier 70%+ des requêtes avec des règles simples (mots-clés), le routage vaut le coup. Sinon, reste avec un agent généraliste.

3. Trois Exemples Concrets

📦 Exemple 1 : Plateforme E-commerce

Contexte : Service qui gère des opérations bulk sur catalogue produits

Types de requêtes :

  • Export simple (70%) : « Génère CSV de 100 produits Électronique » → Agent Haiku + DB
  • Validation complexe (20%) : « Analyse les prix incohérents » → Agent Sonnet + logique métier
  • Synchronisation API (10%) : « Importe produits depuis Shopify » → Agent Sonnet + multi-étapes

Architecture du Router :

Si mots-clés [« export », « csv », « génère »] → Agent_Export (Haiku, 50ms, $0.001) Si mots-clés [« valide », « analyse », « incohérent »] → Agent_Validation (Sonnet, 800ms, $0.015) Si mots-clés [« sync », « import », « api »] → Agent_Sync (Sonnet, multi-steps) Sinon → Escalation humaine

Gain : Coût divisé par 4 (70% des appels utilisent Haiku). Latence P95 : 150ms au lieu de 900ms

💬 Exemple 2 : Support Client Automatisé

Contexte : Chatbot qui gère tickets support

Types de requêtes :

  • FAQ standards (60%) : « Comment réinitialiser mon mot de passe ? » → Agent Haiku + KB statique
  • Résolution technique (25%) : « Mon paiement échoue avec erreur 502 » → Agent Sonnet + logs + troubleshooting
  • Demandes sensibles (10%) : « Je veux annuler mon abonnement » → Escalation immédiate humain
  • Ambiguës (5%) : « Ça ne marche pas » → Escalation

Architecture du Router :

Classification par intention:faq_standard (confiance > 0.90) → Agent_FAQ (Haiku + base connaissances) probleme_technique (confiance > 0.85) → Agent_Tech (Sonnet + accès logs) requete_sensible (détection mots-clés) → Escalation immédiate confiance < 0.85 → Escalation avec contexte

Gain : 60% des tickets résolus automatiquement en <200ms. Agents humains ne traitent que les 40% restants (complexes ou sensibles)

🛡️ Exemple 3 : Content Moderation Platform

Contexte : Plateforme sociale qui modère contenu utilisateur (texte, images, vidéos)

Types de contenu :

  • Texte simple (80%) : Commentaires courts → Agent Haiku + règles lexicales
  • Nuancé (15%) : Sarcasme, contexte culturel → Agent Sonnet + analyse sémantique
  • Multimodal (5%) : Texte + image → Agent Sonnet + vision + cross-modal reasoning

Architecture du Router :

Pré-classification (règles):Si contenu contient mots-clés explicites → Blocage immédiat (0 IA) Si texte seul < 50 mots ET pas de mots sensibles → Agent_Texte_Simple (Haiku) Si texte long OU contexte ambigu → Agent_Nuancé (Sonnet) Si contient média (image/vidéo) → Agent_Multimodal (Sonnet + vision)

Gain : 80% du contenu modéré avec Haiku (10x moins cher). Faux positifs réduits de 40% grâce à la spécialisation

4. Patterns & Anti-Patterns

✅ Patterns Efficaces

Escalation par Confiance

Si le router hésite (confiance < 0.85), escalade vers humain plutôt que de deviner

Règle : 5% d’escalations acceptable. 1 mauvaise décision = coûteux

Règles Heuristiques d’Abord

Pour les cas évidents (mots-clés explicites), évite l’appel IA du router

Exemple : « export csv » → route directe sans classification IA

Contexte Minimal par Agent

Chaque agent ne reçoit QUE ce dont il a besoin. Zéro bleed-over.

Sécurité : Agent_Email ne voit pas les données DB, Agent_DB ne voit pas les templates email

Monitoring Agressif

Track précision, confiance, escalations quotidiennement

Alerte : Si précision < 90%, audit immédiat

❌ Anti-Patterns à Éviter

Anti-PatternConséquenceSolution
Router trop complexeLatence du router > 500ms, annule le gainUtilise règles simples pour 80% des cas, IA seulement pour les ambigus
Trop de catégoriesPrécision chute, confusion entre catégories prochesMax 5-7 catégories bien distinctes
Fallback vers agent généralisteDéfait l’optimisation si le fallback est utilisé 30%+Si >20% de fallback, revoir la stratégie de routage
Pas de loggingImpossible de détecter la dérive de précisionEnregistre chaque décision du router (intention + confiance)

5. Propriétés d’un Bon Router

⚡ Rapide

Latence < 100ms pour 80% des classifications

Si le router prend plus de temps que l’agent, c’est raté

🎯 Déterministe

Même requête → même route

Permet le caching et la prévisibilité

📊 Confiant

Donne un score de confiance avec chaque décision

Escalade si confiance < seuil

🔒 Isolant

Contexte A ≠ Contexte B

Zéro fuite d’information entre branches

🔍 Observable

Chaque décision est tracée

Debug et optimisation possibles

↗️ Escalable

Peut gérer 1M+ requêtes/jour

Architecture stateless

6. Métriques de Succès

MétriqueCibleAlerte siSignification
Précision du Router> 92%< 90%% de requêtes acheminées vers le bon agent
Taux d’Escalation< 5%> 8%% de requêtes envoyées à un humain (confiance faible)
Latence P95 Router< 150ms> 250msTemps de décision du router (95e percentile)
Latence P95 Totale< 500ms> 1sRouter + Agent + Résultat
Économie de Coût> 60%< 40%Réduction coût vs agent généraliste Sonnet partout
Distribution RoutesÉquilibrée1 route > 90%Utilisation de chaque branche spécialisée
Alerte Critique : Si la précision baisse de 5%+ en une semaine, c’est un signal de dérive. Les requêtes utilisateurs évoluent, le router doit s’adapter.

7. Architecture Conceptuelle

Composants Principaux

┌─────────────────────────────────────────────┐ │ REQUÊTE ENTRANTE (hook) │ │ {user_id, query, context, timestamp} │ └─────────────────┬───────────────────────────┘ │ ▼ ┌─────────────────────────────────────────────┐ │ AUTHENTIFICATION & PERMISSIONS │ │ Vérifie JWT, RLS, quotas │ └─────────────────┬───────────────────────────┘ │ ▼ ┌─────────────────────────────────────────────┐ │ ROUTER (Classificateur) │ │ ┌─────────────────────────────────────┐ │ │ │ Règles heuristiques (80% des cas) │ │ │ │ • Mots-clés explicites │ │ │ │ • Patterns simples │ │ │ └──────────┬──────────────────────────┘ │ │ │ │ │ ▼ (si ambigu) │ │ ┌─────────────────────────────────────┐ │ │ │ Classification IA (20% restants) │ │ │ │ • LLM léger pour décider │ │ │ │ • Retourne: {route, confiance} │ │ │ └─────────────────────────────────────┘ │ └─────────────────┬───────────────────────────┘ │ ▼ ┌─────────────────────────────────────────────┐ │ DÉCISION D’AIGUILLAGE │ │ Si confiance >= 0.85: vers agent │ │ Si confiance < 0.85: escalation humain │ └─────────┬───────────────────────────────────┘ │ ┌─────┴─────┬─────────┬─────────┐ ▼ ▼ ▼ ▼ ┌────────┐ ┌────────┐ ┌────────┐ ┌──────────┐ │Agent A │ │Agent B │ │Agent C │ │Escalation│ │(Haiku) │ │(Sonnet)│ │(Sonnet)│ │ (Humain) │ │ │ │ │ │ │ │ │ │Outils: │ │Outils: │ │Outils: │ │Ticket + │ │• DB │ │• API │ │• Vision│ │contexte │ │ │ │• Logic │ │• Files │ │ │ └────┬───┘ └────┬───┘ └────┬───┘ └─────┬────┘ │ │ │ │ └──────────┴──────────┴────────────┘ │ ▼ ┌──────────────┐ │ RÉSULTAT │ └──────────────┘

Points Critiques d’Architecture

1. Le Router est STATELESS
  • Aucune mémoire entre requêtes
  • Chaque décision est indépendante
  • Permet scaling horizontal infini
2. Les Agents sont ISOLÉS
  • Agent A ne partage pas de contexte avec Agent B
  • Chaque agent a son propre system prompt, ses propres outils
  • Zéro bleed-over entre branches
3. Escalation = Soupape de Sécurité
  • Si le router ne sait pas → envoie vers humain avec contexte complet
  • Mieux vaut 5% d’escalations qu’une mauvaise décision automatique
  • L’humain peut ensuite enrichir le dataset de training du router

8. Récapitulatif

En 3 Points Clés

  1. Le routage optimise en spécialisant. Au lieu d’un agent qui fait tout mal, plusieurs agents experts qui font chacun une chose très bien.
  2. Ça vaut le coup si 70%+ des requêtes sont simples. Sinon, la latence du router annule le gain.
  3. Un bon router = Rapide (< 100ms), Précis (> 92%), Confiant (escalade si doute).

Quand Utiliser

  • Requêtes hétérogènes
  • Complexité variable (70% simple, 30% complexe)
  • Volume élevé (10k+ requêtes/mois)
  • Outils mutuellement exclusifs

Quand NE PAS Utiliser

  • 95% des requêtes identiques
  • Catégories ambiguës
  • Faible volume (< 5k/mois)
  • Contexte partagé obligatoire
Erreur Fréquente : Créer un router ultra-sophistiqué qui met 800ms à décider. Si le router est lent, tu as perdu le match. Commence simple (règles + IA légère), optimise ensuite.

Modèle de Routage | Architecture haut niveau pour orchestration intelligente

Pattern Agentique | Divide & Conquer Strategy

Publications similaires