Les systèmes multi-agents sont des systèmes backend comportant des composants non déterministes.
Les systèmes de production multi-agents favorisent des habitudes de type backend : des contrats à chaque frontière, des prompts en tant que configuration, un budget de contexte restreint, un seul rôle par agent, et des tentatives de réessai.
Sources: Multi-Agent Systems Are Backend Systems with Non-Deterministic Components
En venant de la science des données et de l’apprentissage automatique pour aborder l’IA agente, les premières étapes semblent familières. Si l’on reste suffisamment longtemps dans un système multi-agent en production, cela cesse complètement de ressembler à de la science des données. Il commence alors à ressembler à de l’ingénierie backend, avec la particularité que certaines de ses composantes sont non déterministes. Vu sous cet angle, de nombreuses décisions de conception deviennent plus faciles à comprendre.
L’objectif n’est pas d’éliminer la flexibilité que procurent les LLM, car c’est justement cette flexibilité qui motive leur utilisation. L’objectif est plutôt de définir des limites prévisibles autour d’elle.
Donner un contrat à chaque limite
Les LLM communiquent par texte, ce qui incite à laisser les différentes parties d’un système d’agent communiquer entre elles de la même manière. Une composante écrit quelque chose, la suivante le lit et interprète ce qui a été voulu.
Cela fonctionne tant que l’interprétation ne devient pas elle-même une source de doute.
Les demandes de clarification en sont un bon exemple. Un composant peut se rendre compte qu’il lui manque des informations et les expliquer clairement en prose, tout en laissant le reste du flux de travail dans l’incertitude. S’agit-il d’une erreur ou d’une demande de précision ? Faut-il interrompre l’exécution ? Qu’est-ce qui manque exactement ?
La solution consiste à pousser les choses dans cette direction vers des contrats explicites et structurés. Au lieu d’une phrase du type « Je n’ai pas suffisamment d’informations pour continuer, pourriez-vous demander à l’utilisateur quel ensemble de données utiliser ? », les composants échangent un message tel que :
{
"status": "needs_clarification",
"question": "Which dataset should be used?",
"required_input": "dataset"
}
Le format JSON est secondaire. C’est le contrat qui compte. Le composant suivant reçoit un état connu et une forme définie, et n’a jamais besoin d’inférer l’intention à partir d’un texte généré.
L’interaction humaine peut suivre le même schéma. Lorsqu’un composant spécifique à un domaine a besoin d’informations supplémentaires, il envoie une demande de clarification structurée, et une couche d’interaction distincte décide de la manière de la présenter à l’utilisateur. En résumé :
Domain workflow
↓
Structured clarification request
↓
User interaction layer
↓
User
La finalisation mérite le même traitement. Si l’achèvement d’une tâche est important pour l’orchestration, il devrait s’agir d’un événement de protocole défini, et non quelque chose que un second modèle doit déduire de phrases telles que « l’analyse est terminée ».
Cette idée dépasse de loin la simple clarification ou la finalisation. Les messages entre composants, les appels d’outils et leurs réponses, les erreurs ainsi que les événements d’orchestration bénéficient tous de limites explicites.
Une règle pratique : si un autre composant doit interpréter la sortie d’un LLM, cette sortie mérite probablement un schéma.
Le langage naturel doit être utilisé là où il est réellement nécessaire. À l’intérieur du système, l’ambiguïté a tendance à causer plus de problèmes qu’elle n’en résout.
Considérer les prompts comme une configuration
Au fur et à mesure que le système se développe, il devient de plus en plus difficile de gérer l’édition manuelle de chaque prompt système en tant que bloc de texte indépendant. Les règles partagées finissent par être copiées en plusieurs endroits, les descriptions des capacités évoluent avec le temps, et le prompt s’éloigne de ce qui est réellement disponible au moment de l’exécution.
Une configuration plus déclarative aide à y remédier. Les règles partagées, les instructions spécifiques aux rôles, les descriptions des capacités ainsi que les exemples sont conservés séparément et assemblés dans le prompt final lors de la construction.
Étape de construction oblige, vous disposez également d’un moyen de valider la configuration avant même que le modèle ne la voie. Si un prompt prétend disposer d’une capacité qui n’est en réalité pas activée, la phase de construction doit le détecter. Il en va de même pour l’absence de sections obligatoires, les définitions redondantes ou des paramètres qui ne correspondent plus au rôle assigné.
Nul ne modifie directement l’instruction finale. Elle est générée à partir de composants de configuration plus petits, validée, puis émise sous forme d’artefact de compilation que l’on peut versionner et reconstruire à volonté.
À ce stade, la gestion des instructions ressemble beaucoup plus à une configuration logicielle ordinaire qu’à de l’écriture. On réutilise des parties partagées, on valide tout ce qui peut l’être avant l’exécution, et on assure que le résultat généré reste cohérent avec le système environnant.
Le contexte est une ressource limitée
De grands fenêtres de contexte facilitent l’ajout continu de contenus : instructions, exemples, historique, descriptions de capacités, artefacts, résultats antérieurs. Finalement, le modèle dispose de tout ce dont il pourrait théoriquement avoir besoin, ce qui parfois entraîne une baisse de ses performances.
L’explication évidente est la longueur, comme si le modèle oubliait simplement quelque chose. Cependant, avec les modèles actuels, la dilution des instructions constitue souvent un critère plus utile pour analyser le problème.
Le contexte réel d’un agent est bien plus vaste que son prompt système :
instructions
+ available capabilities
+ examples
+ conversation history
+ artifacts
+ previous outputs
+ workflow state
Un modèle peut très bien être capable de localiser une instruction particulière quelque part parmi tout cela. Cela ne signifie pas pour autant qu’il obéira à chaque instruction de la même manière lorsque plusieurs signaux se disputent son attention.
Ainsi, la question plus utile devient de savoir quel est le volume minimal de contexte dont un composant a réellement besoin, par rapport à la quantité que le modèle peut techniquement accepter.
Cela dépasse la simple question d’économie de tokens. Un contexte plus petit et plus pertinent réduit l’espace des décisions et rend le comportement plus facile à prédire. Chaque élément de contexte supplémentaire se dispute l’attention du modèle ; il n’y reste pas gratuitement.
Un agent, un rôle
Le nombre d’outils s’avère être un indicateur peu fiable pour déterminer quand diviser un agent. Un agent peut posséder de nombreuses capacités étroitement liées tout en ayant un but clair, tandis qu’un autre ne disposant que de quelques outils peut déjà s’occuper de plusieurs tâches non liées entre elles.
La responsabilité constitue une meilleure ligne de séparation. Des responsabilités différentes exigent généralement des instructions, un contexte, des règles de validation et des politiques de gestion des erreurs distincts. Il s’agit d’une séparation des préoccupations appliquée aux composants probabilistes.
Séparez en fonction des responsabilités et ignorez le nombre d’outils.
Le graphe conserve l’état
L’optimisation des prompts reçoit beaucoup d’attention dans le travail avec les agents. L’état, en revanche, en reçoit moins.
Il est facile de se concentrer uniquement sur la taille du prompt et d’oublier l’état du graphe. Un prompt soigneusement réduit peut encore être associé à un état qui conserve des sorties et des artefacts provenant de plusieurs étapes antérieures, à moins que cet état ne soit géré intentionnellement.
Dans l’orchestration basée sur des graphes, les messages, les résultats intermédiaires, les artefacts et les sorties précédentes s’accumulent au fur et à mesure que l’exécution progresse dans le graphe. Le graphe se souvient, ce qui est pratique, mais cela signifie que l’état nécessite une conception délibérée.
Un grand artefact créé tôt peut être conservé lors des étapes ultérieures qui n’ont pas besoin de son contenu. Il en va de même pour les grandes réponses issues d’outils et les résultats intermédiaires.
Pour les artefacts plus volumineux, il est généralement préférable de conserver les données en dehors du graphe. Plutôt que cela :
Large artifact
↓
Graph state
↓
Step
↓
Step
↓
Step
Quelque chose de plus proche de ce qui suit est généralement suffisant :
Large artifact
↓
External storage
↓
Reference + metadata
↓
Graph state
La plupart des composants n’ont pas besoin que tout soit produit au préalable dans le flux de travail. Ils n’ont besoin que de ce qui est suffisant pour prendre la décision suivante.
La taille des indications n’est qu’un aspect du problème lié au contexte, et l’état mérite une attention égale. Concevez-le activement, et ne le laissez pas devenir un dépotoir pour tout ce que génère l’exécution.
La fiabilité relève principalement de l’ingénierie
Même avec de bons contrats, des rôles bien définis et un contexte géré avec soin, les agents commettent encore des erreurs surprenantes. Une action échoue, le modèle choisit la mauvaise action ou la répète, un flux de travail se termine prématurément ou dure bien plus longtemps que prévu.
Il existe aussi des cas où chaque étape semble sensée, mais où le flux de travail dans son ensemble ne progresse pas. Le modèle continue de faire des choix valables localement, créant ainsi en pratique une boucle.
Le premier réflexe, surtout pour ceux qui ont commencé à utiliser de grands LLM au début de 2023, est de corriger de tels problèmes dans le prompt. Cela fonctionne parfois. Mais la plupart des mécanismes de fiabilité qui s’avèrent nécessaires ressemblent à de simples techniques d’ingénierie backend :
- retries et timeouts
- limites strictes quant au nombre d’itérations et d’appels d’outils autorisés par exécution
- détection des boucles en surveillant le retour de la même action ou état
- une légère incitation lorsque l’exécution stagne mais pourrait encore se remettre en marche
- états d’échec explicites avec des voies de récupération
Lorsqu’il ne faut pas que quelque chose se produise plus d’un certain nombre de fois, imposer une limite vaut mieux que d’ajouter une nouvelle instruction demandant au modèle de se comporter différemment. Les prompts font partie de l’ingénierie de fiabilité, mais ils ne devraient pas constituer l’ensemble de cette couche de fiabilité.
L’observabilité suit la même logique. Lorsqu’une demande backend ordinaire échoue, les journaux et les traces d’exécution indiquent généralement ce qui s’est passé. Avec un flux de travail agent, savoir où cela a échoué n’est souvent pas suffisant.
Il faut reconstituer comment cela s’est produit : le chemin choisi, les actions tentées, les arguments générés et les résultats retournés. Lors de la débogage en boucle, ce qui est intéressant n’est souvent pas l’erreur finale, mais la chaîne de décisions qui a conduit à renvoyer l’exécution sur le même chemin.
Dans les systèmes agents, on débogue à la fois les décisions et le code ; par conséquent, une bonne observabilité doit permettre de reconstituer le parcours des décisions.
Le choix du modèle est une décision de conception de système
Considérer les agents comme des composants logiciels modifie également la manière dont les modèles sont sélectionnés. Rien ne prouve que chaque composant doive fonctionner avec un seul modèle partagé, et envoyer chacun d’eux vers le modèle le plus volumineux disponible n’a encore moins de sens.
Un système multi-agents mélange naturellement des tâches de difficultés très différentes. Certaines exigent un véritable raisonnement, une planification ou une synthèse. D’autres consistent principalement à acheminer, extraire, classer, transformer des données structurées ou à choisir parmi un petit ensemble d’actions.
Un modèle de pointe peut fonctionner partout, mais il peut aussi rendre le système inutilement lent et coûteux. Ce qui importe pour chaque rôle, c’est l’équilibre entre qualité, fiabilité, latence et coût.
Le choix va également au-delà du nombre de paramètres ou des classements sur les classements. Des modèles qui se ressemblent sur les benchmarks peuvent se comporter de manière très différente au sein du même flux de travail.
L’architecture est un facteur important, car les modèles denses, ceux basés sur une combinaison d’experts et les modèles hybrides diffèrent par leur nature. La phase post-entraînement compte également : différentes méthodes d’ajustement supervisé, d’optimisation des préférences et d’apprentissage par renforcement influencent la capacité à suivre des instructions, à raisonner, à utiliser des outils, à produire des résultats structurés et à adopter des comportements atypiques.
Les compromis en pratique sont concrets. Un modèle peut être rapide, peu coûteux et fiable pour des tâches spécifiques comme le routage ou la classification, mais il comble parfois les lacunes par des raisonnements plausibles lors d’étapes ouvertes. Un autre modèle peut être plus lent et plus cher, mais il offre une stabilité nette dans le raisonnement à plusieurs étapes.
Il n’est pas nécessaire d’entraîner ces modèles pour que cela ait de l’importance. Connaître leurs différences de comportement vous aide à décider où chacun d’eux doit être intégré au sein d’un système plus large.
Le critère le plus important est votre charge de travail réelle. Pour le routage, testez le routage lui-même. Lorsque la sortie doit correspondre à un schéma, comptez la fréquence à laquelle cela se produit. Les composants qui reposent sur le raisonnement disposent d’un ensemble de cas de raisonnement typiques. Intégrez la latence et le coût dans la même évaluation.
Jugez un modèle en fonction du rôle qu’il joue dans votre système et non en fonction de son classement global.
Ingénierie face au non-déterminisme
Il existe une direction commune à tout cela. Les premiers prototypes d’agents maximisent la liberté : on donne au modèle des instructions, des outils et un contexte, puis on le laisse décider.
Lorsque l’on passe à l’environnement de production, une grande partie du travail se fait dans le sens inverse. Les responsabilités se restreignent, les interfaces deviennent structurées, le contexte devient plus pertinent, l’état est géré de manière intentionnelle, les chemins d’échec sont explicites et le choix du modèle dépend de son rôle.
Même les prompts cessent d’être du texte isolé pour devenir ce qui ressemble à une configuration qu’il faut assembler, valider, versionner et reproduire.
Rien de tout cela ne supprime la capacité du LLM de prendre des décisions. Si chaque décision pouvait être déterministe, il n’y aurait guère de raison de créer un système agent. Ce qui compte, c’est de choisir où le non-déterminisme est utile et où il ne l’est pas.
C’est pourquoi ces systèmes ressemblent de plus en plus à de l’ingénierie backend avec un nouveau type de composant. Le LLM offre de la flexibilité à l’intérieur des limites fixées par l’ingénierie logicielle.
Le meilleur système agent n’est pas celui où les agents peuvent faire le plus. C’est celui où ils disposent exactement de la liberté dont ils ont besoin.
Lectures complémentaires
- Notes pratiques : Google ADK expliqué – Création de systèmes multi-agents avec — Guide pas à pas des Notes pratiques : Google ADK expliqué – Création de systèmes multi-agents avec : contrats, vérifications et emplacements de code prêts à l’emploi pour les équipes utilisant ce modèle.
- Systèmes multi-agents LangGraph : superviseurs, sous-graphes et fonction Send — Passer d’un agent surchargé à plusieurs : routage par superviseur, diffusion et concentration des données, sous-graphes, réduction de carte basée sur la fonction Send, ainsi qu’un assistant de recherche complet pour les systèmes multi-agents dans LangGraph.