🤖 AI

Retrieval-Conditioned Topology Selection with Provable Budget Conservation for Multi-Agent Code Generation

Ce document présente l'Orchestration Adaptative Guidée par la Récupération (RGAO), un cadre multi-agents qui sélectionne dynamiquement des topologies de génération de code basées sur la complexité structurelle extraite d'un index de code hiérarchique, permettant ainsi d'assurer une conservation prouvable du budget grâce à l'intégration novatrice d'un routage conditionné par la complexité et d'algèbres de ressources formelles.

Auteurs originaux : Abhijit Talluri, Pujith Anne, Bhagavan Choudary Pendiyala, Raghavendra Chilukuri

Publié 2026-05-08

📖 4 min de lecture☕ Lecture pause café

CC BY 4.0

Auteurs originaux : Abhijit Talluri, Pujith Anne, Bhagavan Choudary Pendiyala, Raghavendra Chilukuri

Article original sous licence CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Ceci est une explication générée par l'IA de l'article ci-dessous. Elle n'a pas été rédigée ni approuvée par les auteurs. Pour une précision technique, consultez l'article original. Lire la clause de non-responsabilité complète

Imaginez que vous êtes le manager d'une équipe d'assistants IA hautement qualifiés, mais très coûteux. Votre objectif est de corriger des bugs ou d'écrire du nouveau code pour un projet logiciel massif.

Le problème avec les équipes d'IA actuelles est qu'elles sont ignorantes de la taille de la tâche.

Si vous leur demandez de corriger une faute de frappe dans un seul fichier, elles pourraient envoyer toute l'"équipe d'intervention" avec une grue, une bulldozer et une équipe de démolition. C'est une perte de temps et d'argent.
Si vous leur demandez de reconstruire le réseau électrique d'une ville entière (un changement complexe touchant de nombreux fichiers), elles pourraient n'envoyer qu'une seule personne avec un tournevis. Cela conduit à l'échec.

Ce papier présente un nouveau système appelé CODE-AGENT avec un manager spécial nommé RGAO. Voici comment cela fonctionne, en utilisant des analogies simples :

1. Le "Éclaireur" avant l'"Équipe" (Routage guidé par la récupération)

Dans les anciens systèmes, le manager ne regardait que les mots que vous avez tapés pour décider qui envoyer. Si vous disiez "corriger la connexion", ils supposaient qu'il s'agissait d'une grosse tâche.

RGAO change la donne. Avant d'envoyer qui que ce soit, il envoie un Éclaireur pour examiner le code réel.

L'Éclaireur grimpe dans la structure du code (comme un arbre) et mesure des choses telles que : "Quelle est la profondeur des racines ?" "Combien de branches sont emmêlées ?" "Combien de bâtiments différents cela affecte-t-il ?"
Sur la base de cette carte structurelle, le manager choisit la bonne équipe :
- FASTPATH : Une toute petite faute de frappe ? Envoyez une personne pour la corriger instantanément.
- SUBAGENT : Une petite fonctionnalité ? Envoyez un spécialiste.
- MULTIAGENT : Un gros changement ? Envoyez une chaîne d'experts travaillant ensemble.
- DEEPRESEARCH : Une demande confuse et vague ? Envoyez une équipe pour faire des recherches approfondies d'abord.

Le Résultat : Le papier affirme que cette méthode d'"Éclaireur" a réduit le nombre de mauvais assignements d'équipe de 30 % à 8 %. C'est comme un général regardant une carte avant de décider d'envoyer un tireur d'élite ou une armée.

2. Le "Budget Inviolable" (Conservation prouvée du budget)

Les agents IA sont coûteux ; ils consomment des "jetons" (comme du carburant) et du temps. Si un agent reste bloqué dans une boucle ou devient fou, il peut consumer tout votre budget en quelques secondes.

Les auteurs ont créé un Filet de sécurité mathématique.

Imaginez le manager principal comme un parent avec une allocation de 100 $.
Lorsque le parent envoie un enfant (un sous-agent) faire une tâche, il donne à l'enfant une allocation stricte (par exemple, 10 $).
Le système possède une preuve mathématique (Théorème 1) qui dit : "Peu importe le nombre d'enfants que vous envoyez, ou le nombre de fois qu'ils réessaient, l'argent total dépensé par toute la famille ne dépassera jamais les 100 $ initiaux du parent."

Pourquoi c'est spécial : La plupart des systèmes vérifient le budget pendant que le travail est en cours (et s'ils manquent de fonds, il est trop tard). Ce système vérifie les mathématiques avant que quiconque ne commence à travailler. Si le plan semble coûter 110 $, le système dit "Non, annulez ce plan" avant qu'un seul dollar ne soit dépensé.

3. La "Chaîne de Montage" (Architecture)

Le système fonctionne en couches :

L'Éclaireur : Lit l'arbre du code et mesure la complexité.
Le Dispatcher : Utilise les mesures pour choisir la bonne taille d'équipe.
Le Comptable : Vérifie les mathématiques pour s'assurer que l'équipe ne dépensera pas trop.
Les Travailleurs : Les agents IA réels effectuent la programmation, se passant des notes entre eux de manière efficace sans crier par-dessus les autres (ce qui économise du temps).

La Conclusion

Le papier affirme que cette combinaison — examiner d'abord la structure du code et garantir mathématiquement que vous ne dépenserez pas trop — crée un système beaucoup plus intelligent sur qui envoyer et combien cela coûtera.

Note importante du papier :
Les auteurs sont honnêtes sur les limites. Ils l'ont testé sur un "proxy" (une simulation) car exécuter les tests réels complets est trop coûteux et risqué pour le moment. Ils admettent également que si le code est dans un langage que leur "Éclaireur" ne connaît pas bien (comme Rust, qu'ils apprennent encore), le système n'est pas tout à fait aussi affûté. Mais pour les tests qu'ils ont réalisés, cela a fonctionné significativement mieux que les anciennes méthodes de "devinette basée sur les mots-clés".

Résumé technique : Sélection de topologie conditionnée par la récupération avec conservation prouvable du budget pour la génération de code multi-agent

Énoncé du problème

Les systèmes multi-agents basés sur des modèles de langage de grande taille (LLM) pour la génération de code font face à un défi fondamental de routage : déterminer la topologie d'orchestration optimale (par exemple, monolithique, spécialiste unique, pipeline/essaim, ou axée sur la récupération) en fonction de la complexité structurelle du code à modifier. Les systèmes existants sélectionnent généralement les topologies en utilisant des caractéristiques de requête de surface (par exemple, des classificateurs regex) ou des graphes de dépendance de tâches sans consulter la structure réelle de la base de code. Cela entraîne un « mauvais routage », où des modifications simples sont acheminées via des pipelines complexes ou inversement, engendrant des pénalités d'efficacité inutiles. De plus, bien que des algèbres de ressources formelles existent pour gérer les budgets des agents, elles manquent souvent d'intégration avec la sélection dynamique de topologie, et les garanties de ressources sont fréquemment appliquées uniquement au moment de l'exécution plutôt que statiquement.

Méthodologie : CODE-AGENT et RGAO

L'article présente CODE-AGENT, un cadre multi-agent centré sur l'Orchestration Adaptative Guidée par la Récupération (RGAO). Le système fonctionne via une boucle fermée où les signaux de récupération informent directement les décisions d'orchestration, couplés à une algèbre de budget formelle garantissant la conservation des ressources.

1. Récupération hiérarchique du code et extraction de complexité

Avant le routage, le système effectue une passe de récupération sur un index arborescent hiérarchique du dépôt de code (Racine $\to$ Répertoire $\to$ Fichier $\to$ Symbole).

Stratégie de récupération : Les requêtes sont classées en cinq types (identifiant, exacte, conceptuelle, dépendance, structurelle). Les requêtes conceptuelles déclenchent une stratégie de fusion multi-chemin combinant LATTICE (calibration des scores de chemin), KohakuRAG (reformulation multi-requêtes) et PageIndex (recherche en faisceau guidée par LLM), fusionnées via la fusion des rangs réciproques (RRF).
Vecteur de complexité ( $c$ ) : À partir du sous-graphe récupéré, RGAO extrait un vecteur de complexité structurelle à cinq dimensions en moins d'une milliseconde :
$c = (d_{dep}, n_f, n_s, h_t, \rho_x)$
Où $d_{dep}$ est la profondeur maximale de dépendance, $n_f$ le nombre de fichiers, $n_s$ le nombre de symboles, $h_t$ la profondeur de l'arbre, et $\rho_x$ le taux de couplage inter-module.

2. Orchestration Adaptative Guidée par la Récupération (RGAO)

Le routeur de topologie est un classificateur déterministe par seuil qui mappe le vecteur de complexité $c$ et la requête utilisateur vers l'une des quatre topologies :

FASTPATH : Exécution monolithique pour des modifications triviales sur un seul fichier.
SUBAGENT : Contrat de spécialiste unique pour une portée modérée ( $n_f \le 3$ ).
MULTIAGENT : Pipeline linéaire ou essaim parallèle pour des tâches complexes sur plusieurs fichiers ( $n_f > 3$ ).
DEEPRESEARCH : Exécution multi-étapes, axée sur la récupération, pour des requêtes ambiguës.

3. Algèbre de budget formelle et vérification statique

Les sous-agents sont régis par des contrats formels $\langle I, C, T, M \rangle$ , où $C$ inclut un vecteur de budget à six dimensions (itérations, appels, jetons, secondes, nouvelles tentatives, transferts).

Théorème de conservation du budget (Théorème 1) : L'article prouve que, sous des hypothèses spécifiques (coûts d'outils déterministes, profondeur de récupération bornée, espace d'actions fini), la consommation totale de ressources d'une forêt de délégation est bornée par le budget racine.
Vérification statique : Un algorithme VERIFYCONSERVATION vérifie l'algèbre de budget en temps $O(|V| + |E|)$ avant tout appel LLM. Il garantit que la somme des budgets enfants plus les coûts directs ne dépasse pas le budget parent, empêchant les dépassements de ressources de manière statique plutôt que réactive.

4. Couche d'exécution

Le système utilise un SwarmSupervisor pour construire un graphe orienté acyclique (DAG) de tâches. Il applique un protocole de pré-exécution à trois portes (existence du contrat, faisabilité du budget, intégrité du transfert) et utilise des objets SwarmArtifact typés pour la communication inter-agent, réduisant la surcharge de coordination de $O(n^2)$ à $O(k)$ .

Contributions clés

Routeur de topologie conditionné par la complexité : Un routeur qui mappe les signaux de structure de code dérivés de la récupération vers des décisions d'orchestration, réduisant considérablement les taux de mauvais routage par rapport aux bases de référence regex.
Conservation prouvable du budget : Un théorème d'induction structurelle (Théorème 1) garantissant que la délégation hiérarchique de contrats ne dépasse jamais les limites parentales, vérifiée statiquement en temps linéaire par rapport à la taille du DAG.
Moteur de récupération hiérarchique : Une combinaison novatrice de LATTICE, KohakuRAG et d'une expansion de dépendance de style RepoGraph sur un index arborescent, utilisée spécifiquement comme signal de routage.
Composition du système : L'intégration du routage conditionné par la récupération avec la vérification statique du budget, une propriété qu'aucun des deux composants n'admet seul.

Résultats empiriques

L'évaluation a été réalisée à l'aide d'un dispositif de test proxy (evals/swebench_proxy.py) pour abstraire les interactions en bac à sable, les exécutions complètes de SWE-bench étant reportées à une passe ultérieure en raison de préoccupations de contamination et de contraintes de ressources.

Précision du routage : Sur un jeu de données étiqueté de 250 instances, RGAO a réduit le mauvais routage de 30,1 % (base de référence regex) à 8,2 % (IC de Wilson à 95 % [6,1, 10,9]), une amélioration statistiquement significative (McNemar apparié, $p < 10^{-6}$ ).
Surcharge de performance :
- Construction du DAG : Inférieure à une milliseconde (< 0,01 ms).
- Construction de l'index arborescent (200 fichiers, 2 002 nœuds) : 11,1 ms.
- Instantiation de l'usine de contrats : ~1,1 $\mu$ s.
- Surcharge de vérification du budget : ~0,65 $\mu$ s.
Correction du pipeline : Le système a complété 100 % des cinq pipelines multi-agents composés (incluant des scénarios de récupération d'intervention) avec un coût moyen de jetons d'environ 6 000 jetons par pipeline.
Benchmarks proxy : CODE-AGENT a résolu 40 % d'un ensemble SWE-bench synthétique à pass@1, démontrant une efficacité par rapport aux agents monolithiques non contraints (réduction de 8 à 20 fois des jetons).

Importance et revendications

L'article revendique que son importance principale réside dans la composition de deux lignes de recherche précédemment séparées : le routage conditionné par la complexité des LLM et les algèbres de ressources formelles.

Nouveauté : Ni le routage conditionné par la complexité ni l'algèbre de budget formel seul ne produisent la propriété de « conservation prouvable du budget sous sélection de topologie dynamique conditionnée par la récupération ».
Sécurité et efficacité : Le mécanisme de vérification statique permet au système de rejeter les configurations non réalisables avant l'exécution, limitant le « rayon d'explosion » des erreurs d'agent et réduisant la barrière de coût pour la génération de code agentique dans des environnements à ressources limitées.
Interprétabilité : Contrairement aux politiques de routage apprises, le routeur RGAO utilise des seuils interprétables et ajustés à la main basés sur des signaux structurels, s'alignant sur le récit de sécurité basé sur les contrats.

Les auteurs reconnaissent des limites, notamment la dépendance à des hypothèses de coûts déterministes pour le théorème de conservation stricte (bien que des bornes attendues soient fournies pour des coûts stochastiques) et l'utilisation actuelle de seuils ajustés à la main plutôt que d'un successeur appris. Ils notent que l'avantage de routage se réduit sous des décalages de distribution (par exemple, langues inhabituelles) où la grammaire tree-sitter peut dégrader le vecteur de complexité.