Le vrai problème des systèmes multi-agents
Les frameworks multi-agents se multiplient : LangGraph, CrewAI, AutoGen, OpenAI Agents SDK. Ils sont puissants. Mais ils partagent tous le même angle mort : aucun ne vous dit comment construire un système fiable avec.
Trois problèmes reviennent systématiquement en production.
Le non-déterminisme : quand des agents dialoguent librement, leurs comportements deviennent imprévisibles. Les scratchpads partagés polluent le contexte au lieu de le clarifier.
L'auto-correction illusoire : les LLMs corrigent mieux les erreurs des autres que les leurs. Le taux de correction de ses propres erreurs plafonne à 64.5% en moyenne. Se fier à l'auto-correction, c'est accepter qu'un tiers des erreurs passe en silence.
L'explosion des coûts : sans contrôle strict des flux, les systèmes multi-agents génèrent des boucles infinies ou des échanges superflus qui multiplient les tokens de manière exponentielle.
AOPD 3.0 est né de ces constats. Ce n'est pas un framework technique de plus. C'est une méthodologie qui prescrit comment utiliser les frameworks existants pour construire des systèmes fiables.
Trois axiomes, pas de compromis
AOPD 3.0 repose sur trois principes non négociables.
Séparation neuro-symbolique. L'agent orchestre, le code exécute. Un agent ne doit jamais simuler une logique qui peut être codée de manière déterministe. Un LLM qui fait un calcul, c'est un anti-pattern. Un LLM qui décide quel calcul lancer et interprète le résultat, c'est un agent bien conçu.
Flow Engineering. La collaboration émergente entre agents est remplacée par des flux dirigés. Tout graphe d'agents doit avoir un état de fin et un mécanisme de terminaison garanti. Plus de conversations ouvertes entre agents : des transitions typées, conditionnelles et validées par du code.
Fiabilité probabiliste. AOPD ne crée pas des logiciels qui pensent. Il crée des logiciels probabilistes fiables, mesurables et auditables. Chaque décision d'un agent produit un score de confiance calibré, pas estimé au doigt mouillé.
L'Agent Unit : anatomie d'un agent fiable
Au coeur d'AOPD 3.0, chaque agent est structuré en quatre composants distincts.
Le Brain (composant neural) gère l'intention, l'analyse contextuelle et le raisonnement sémantique. Il choisit les outils à appeler et génère les paramètres. Mais il n'exécute jamais de logique métier directement.
Le Tool (composant symbolique) exécute les actions déterministes : appels API, calculs, requêtes. Chaque outil a une signature typée, un comportement déterministe et une gestion d'erreurs explicite.
Le Validator vérifie la conformité de chaque sortie. En mode symbolique (recommandé en production), il applique des règles codées et des schémas JSON. En mode LLM-as-Judge, un second modèle évalue la qualité, avec un protocole qui atténue le biais d'auto-préférence en utilisant un modèle différent du Brain.
Le Confidence Estimator (composant méta) évalue la confiance indépendamment du Validator. Il combine confiance intrinsèque (probabilités du modèle), confiance contextuelle (similarité avec les cas d'entraînement) et confiance de consistance (accord entre générations multiples).
Le circuit de décision
Si la confiance dépasse le seuil calibré : le flux continue. Si elle est légèrement en dessous : reformulation et retry. Si elle est nettement insuffisante : escalade humaine. Le seuil n'est jamais choisi arbitrairement, il est dérivé empiriquement par calibration.
Quatre topologies selon vos besoins
AOPD 3.0 définit quatre modes de collaboration entre agents, chacun adapté à un contexte précis.
Le Supervisor centralise le contrôle. Un agent superviseur route explicitement les tâches et gère l'état global. C'est la topologie la plus auditable et la plus simple à implémenter, idéale pour les pipelines séquentiels.
Le Hierarchical organise les agents en équipes spécialisées avec délégation en cascade. Chaque niveau peut paralléliser son travail. C'est le choix pour les projets complexes multi-domaines.
Le Peer-to-Peer permet la communication directe entre agents via un protocole de messages structurés. Utile pour la négociation et le consensus, mais réservé aux systèmes avec un niveau de strictness élevé.
Le Swarm libère des agents autonomes avec des règles locales et un état partagé. Les comportements collectifs émergent. C'est puissant pour l'exploration, mais réservé strictement au mode exploration, jamais en production.
CogOps 2.0 : l'observabilité au centre
Un système autonome sans observabilité est inutilisable à l'échelle. AOPD 3.0 intègre CogOps 2.0, une couche d'observabilité conçue spécifiquement pour les systèmes multi-agents.
Chaque interaction produit une trace complète : identifiant, timestamps, entrées/sorties hashées, spans d'exécution détaillés (raisonnement du Brain, exécution des outils, résultats de validation), score de confiance décomposé, coût en tokens et en dollars, et lignage complet (quelle trace a déclenché quelle autre).
Trois niveaux de métriques surveillent le système en continu :
- Micro (par agent) : précision sur le Golden Dataset >= 95%, taux d'hallucination d'outils < 1%, latence P99 < 10s
- Méso (par interaction) : taux de handoff réussi >= 98%, taux d'escalade < 10%, nombre de cycles < 3
- Macro (système) : taux de succès end-to-end >= 95%, score de drift avec alerte au-delà de 5%
Trois circuit breakers protègent automatiquement le système : anti-boucle (détection de répétitions par similarité cosinus), confiance (escalade ou abort si le seuil est franchi), et budget (limites de tokens et de coût en dollars).
Conformité EU AI Act intégrée
AOPD 3.0 intègre nativement la conformité avec le règlement européen sur l'IA. Le framework mappe chaque exigence des articles 9 à 15 vers des composants concrets de l'architecture.
La gestion des risques (article 9) s'appuie sur une méthodologie FMEA trimestrielle. La documentation technique (article 11) est auto-générée à partir des IntentSpecs, des traces et des Golden Datasets. La supervision humaine (article 14) est garantie par les mécanismes d'escalade et les boutons d'arrêt intégrés.
Le dossier de conformité complet peut être généré automatiquement, avec les dix documents requis et leurs annexes.
Eval-Driven Development : tester le probabiliste
Le TDD classique ne fonctionne pas pour les systèmes probabilistes. AOPD 3.0 le remplace par l'Eval-Driven Development (EDD) : on ne développe pas une fonctionnalité, on optimise une métrique.
Le processus est clair : définir un Golden Dataset d'au moins 100 exemples, mesurer le score de base, itérer (changement de prompt, run d'évaluation, vérification du score), et livrer uniquement quand le score atteint la cible.
Les tests adversariaux complètent le dispositif : entrées malformées, cas limites, tentatives d'injection, cas hors distribution. En production, un échantillonnage continu (1-10%) surveille la dérive.
Ce que ça change concrètement
AOPD 3.0 n'est pas un framework académique. C'est une méthodologie opérationnelle, agnostique des implémentations, avec des mappings de référence vers LangGraph et CrewAI.
Si vous construisez un système multi-agents aujourd'hui, la question n'est plus "quel framework choisir". C'est "quelle discipline appliquer pour que ce système reste fiable dans la durée".
Le framework est publié en open-source sous licence CC BY-SA 4.0. La roadmap prévoit une couche d'ontologie domaine (Q2 2026), la formalisation mathématique complète des métriques (Q3 2026) et un SDK Python officiel (Q4 2026).