Accueil / Articles

Lorsque l’équipe d’agents AutoGen est bloquée : la mesurer et escalader vers un superviseur.

Une expérience AutoGen avec un arbitre à horaire de changement déterministe montre pourquoi la revue par les pairs échoue, comment détecter une équipe bloquée, et pourquoi l’escalade nécessite un modèle différent.

Éditeur : REACTAPP.TOP9 min de lecture2149 mots

Sources: AutoGen ile Multi-Agent Eskalasyon: Ekip Takılınca Ne Olur?

Une équipe d’agents peu coûteux peut, par des mesures, se rendre compte qu’elle est bloquée et confier la tâche à un superviseur plus compétent. La question de savoir quel superviseur compte comme étant le plus compétent s’est avérée être une surprise. Ce qui suit est une expérience AutoGen en quatre étapes : un seul agent, une équipe de deux agents, un validateur déterministe et, enfin, une escalade.

La plupart des démonstrations multi-agents rejouent une seule scène : les agents échouent à résoudre un problème, se consultent entre eux, et finalement un agent spécialisé intervient pour terminer le travail. Cela semble impressionnant jusqu’à ce que l’on consulte le code et que l’on trouve une ligne dans le message système disant quelque chose comme « si vous ne pouvez pas le résoudre, demandez au superviseur ». L’agent ne demande pas de l’aide parce qu’il a échoué ; il le fait parce qu’on le lui a ordonné. Toute la scène est écrite à l’avance.

Rien n’est appris de cela, car la vraie question n’est pas de savoir comment un agent demande de l’aide. La vraie question est de savoir comment quelqu’un peut découvrir qu’une équipe est bloquée. L’expérience présentée ci-dessous a été conçue de manière à ce que le blocage se produise réellement, et au cours de celle-ci deux constats ont contraint à des modifications du design. Ces deux éléments se sont avérés être les plus précieux.

Retirer les agents de leur rôle de juges

Si vous voulez voir des agents échouer réellement, ils ne peuvent pas être ceux qui décident ce que signifie le succès. Par conséquent, la tâche doit avoir un résultat que une machine puisse vérifier : un planning hebdomadaire des équipes pour une petite boutique. Il y a sept jours, chacun avec deux équipes, et chaque équipe nécessite exactement deux personnes, ce qui fait 28 postes à pourvoir. Sept employés sont disponibles, avec une capacité totale de 33 équipes. Six règles strictes s’appliquent :

  1. Chaque équipe compte exactement deux personnes.
  2. Nul ne travaille deux équipes le même jour.
  • Quiconque ferme le soir ne peut pas ouvrir le lendemain matin, car 11 heures de repos sont requises.
  • Les limites hebdomadaires s’appliquent : cinq tours de service pour les employés à temps plein et trois pour ceux à temps partiel.
  • Nul ne travaille un jour de repos.
  • Chaque tour de service comprend au moins une personne certifiée comme caissière.
  • La difficulté réside dans l’intersection des règles trois et six. L’une des caissières certifiées est à temps partiel et ne peut effectuer que trois tours de service par semaine. Si l’on modifie la règle concernant le repos, la règle sur les caissières est enfreinte ; si l’on modifie celle-ci, une limite est dépassée.

    Le vérificateur n’est qu’une fonction Python ordinaire ne contenant aucune appel à un LLM.

    def dogrula(cizelge: dict) -> list[str]:
        """Cizelgedeki butun kural ihlallerini dondurur. Bos liste = gecerli plan."""
    

    Toute décision de réussite ou d’échec dans l’expérience provient de cette fonction, et ce que les agents pensent de leur propre travail est sans importance. Les tests prouvent également que le problème est résolvable, car un solveur par rétrogradation dans l’ensemble de tests trouve au moins un planning valide. Les agents ne voient jamais ce solveur. Une fois que l’équipe est bloquée, personne ne peut affirmer que le problème était impossible.

    Étape 1 : un seul agent et quatre violations

    La configuration la plus simple utilise un AssistantAgent sans outils ni assistants :

    planlayici = AssistantAgent("planlayici", model_client=istemci, system_message=...)
    sonuc = await planlayici.run(task=brif())
    

    Avec gpt-4o-mini comme modèle, le résultat a été un planning JSON bien structuré et fiable. L’arbitre a compté quatre violations. Un employé avait un jour de congé prévu un lundi. Le samedi soir, il n’y avait pas de caissier certifié. Un employé à temps partiel ayant une limite de trois tours de service a reçu cinq tours. L’agent n’a aucun moyen de connaître tout cela, car rien dans sa configuration ne lui permet de vérifier sa propre réponse.

    Étape 2 : ajouter un collègue a aggravé la situation

    La solution standard consiste à avoir un réviseur à côté du planificateur. Dans AutoGen, cela nécessite trois lignes :

    ekip = RoundRobinGroupChat([planlayici, denetci], max_turns=6)
    sonuc = await Console(ekip.run_stream(task=brif()))
    

    L’analyseur a fait son travail en identifiant cinq violations, toutes relevant de la règle des 11 heures de repos. Le planificateur les a corrigées. Lorsque l’arbitre a ensuite examiné le calendrier, il n’a trouvé qu’une seule violation liée au repos, ce qui signifie que l’analyseur en avait inventé quatre. En même temps, il avait complètement manqué les infractions relatives aux jours de congé, l’absence de personnel pour la caisse et les dépassements hebdomadaires. Le nombre de violations est ainsi monté à sept, pire que dans le cas de l’agent unique.

    Rien de tout cela n’est surprenant. L’analyseur est également un LLM, il présente donc les mêmes faiblesses et consomme deux fois plus de tokens. L’équipe peut également approuver son propre travail : une fois que l’analyseur annonce que le plan est approuvé, personne ne s’y oppose. C’est comme un étudiant qui note sa propre copie d’examen.

    Étape 3 : des retours corrects ne suffisent toujours pas

    La prochaine étape consiste à retirer la validation au LLM pour la confier à la fonction. AutoGen accepte des fonctions Python simples en tant qu’outils, générant le schéma à partir des indications de type et la description à partir du docstring :

    denetci = AssistantAgent(
        "denetci",
        tools=[cizelgeyi_dogrula],
        max_tool_iterations=1,
        reflect_on_tool_use=False,   # <-- kilit satır
    )
    

    La valeur reflect_on_tool_use=False est cruciale ici. Lorsque cette valeur est True, l’agent résumerait les résultats de l’outil en ses propres mots, le planificateur interpréterait les violations à partir de ce résumé, et les détails seraient perdus. Lorsque cette valeur est False, le rapport du validateur est intégré à la conversation mot pour mot. Le deuxième élément clé est la règle d’arrêt :

    bitis = TextMentionTermination("GECERLI:", sources=["denetci"]) | MaxMessageTermination(12)
    

    Seul le validateur peut générer le texte GECERLI: ; par conséquent, la fin de la conversation est déterminée par un signal déterministe plutôt que par une phrase issue d’un LLM. Cela résout le problème du « plan approuvé » constaté à l’étape précédente.

    Résultat : l’équipe a atteint sa limite de 12 messages avec neuf violations. La situation semble effectivement plus grave. Les retours sont désormais précis, sans violations inventées ni règles manquées. Cependant, le petit modèle corrige une règle tout en en enfreignant une autre, et le processus ne converge jamais. Des retours corrects sont nécessaires, mais insuffisants. Ce qui manque, c’est un mécanisme permettant de mesurer les progrès et de déclarer que cette équipe ne terminera pas le travail.

    Étape 4 : mesurer l’impasse

    La première question à se poser pour déterminer s’il faut escalader la situation est de savoir si l’équipe est vraiment bloquée ou simplement lente. Demander aux agents n’a aucun sens, car s’attendre à un rapport honnête de leur part dans un système incapable d’évaluer son propre travail revient à reproduire l’erreur de la deuxième étape. C’est pourquoi le code effectue des mesures en utilisant deux signaux :

    def takildi_mi(self, sabir: int = 2) -> tuple[bool, str]:
        son, onceki = self.denemeler[-1], self.denemeler[-2]
    
        # 1. Ayni ihlal seti tekrar ediyor -> dongude donuyorlar.
        if son.cizelge is not None and son.ihlaller == onceki.ihlaller:
            return True, "Ayni ihlaller iki tur ust uste tekrarlandi."
    
        # 2. Son turlarda ihlal sayisi hic azalmadi -> ilerleme yok.
        pencere = self.denemeler[-(sabir + 1):]
        if pencere[-1].skor >= min(d.skor for d in pencere[:-1]):
            return True, "Ilerleme yok."
    
        return False, ""
    

    Si aucun signal n’est déclenché, l’équipe progresse, même lentement, et le cycle se poursuit. Cette vérification permet également au système d’intervenir avant que le budget de la manche ne s’épuise, ce qui est important car chaque manche gaspillée représente de l’argent perdu. L’orchestration se fait grâce à une boucle Python ordinaire. AutoGen conserve l’historique des conversations de l’équipe, de sorte que l’appel répété au même objet d’équipe fait en sorte que l’équipe se souvienne des manches précédentes :

    for tur in range(1, MAX_TUR + 1):
        sonuc = await Console(ekip.run_stream(task=gorev))
        cizelge = son_cizelge(sonuc.messages)
        ihlaller = dogrula(cizelge)
        gunluk.ekle(Deneme(tur, cizelge, ihlaller))
    
        if not ihlaller:
            break
        takildi, sebep = gunluk.takildi_mi()
        if takildi:
            break
        gorev = sonraki_gorev(...)
    

    Contenu du package d’escalade

    L’équipe est bloquée, alors que transmettre au superviseur ? Il est le plus simple de poser à nouveau la question depuis zéro, mais il s’agit d’une nouvelle tentative et non d’une escalade. Ce dont a besoin le superviseur, ce n’est pas le problème lui-même, mais ce que l’équipe a essayé et pourquoi cela a échoué. Le package contient :

    • un résumé du problème,
    • le rapport de non-respect des délais généré à chaque étape,
    • les types de non-respect qui se reproduisent, avec des comptes (comme jour de congé : 3 fois, limite : 3 fois),
    • les derniers messages de l’équipe,
    • une définition claire de la tâche.

    La ligne des non-respects récurrents est un simple compteur, mais elle fonctionne bien, car le superviseur voit d’un coup d’œil quelle règle empêche l’équipe de progresser.

    Résultat 1 : max_tool_iterations est une limite maximale, pas une garantie

    Le superviseur a reçu l’outil de validation avec max_tool_iterations=8. On s’attendait à un cycle autonome comprenant la rédaction, la validation, la correction, puis une nouvelle validation. Ce qui s’est réellement passé, c’est que le superviseur a appelé l’outil une fois, a reçu un rapport indiquant trois violations, puis a retourné un planning complètement différent comme réponse finale sans le valider. Ce planning était invalide.

    La valeur de configuration est une limite supérieure et jamais inférieure. Dès que le modèle répond par du texte au lieu d’une appel à outil, la boucle s’arrête. Écrire « jamais répondre sans validation » dans le message système n’a pas non plus aidé, puisque cette phrase s’y trouvait déjà. La solution a été d’ordre architectural : laisser le dernier mot au juge et non au modèle. Le superviseur s’exécute désormais à l’intérieur de la même boucle de validation externe que l’équipe, et sa réponse n’est acceptée qu’après approbation par le juge. Dire à un modèle ce qu’il doit faire ne suffit pas pour que cela se produise. Si vous avez besoin d’une garantie, vous devez construire la boucle vous-même.

    Résultat 2 : un modèle plus performant n’était pas suffisant

    Le premier superviseur était gpt-4o, qui dirigeait une équipe de travailleurs composée de gpt-4o-mini. C’est la configuration classique où le modèle bon marché s’occupe des tâches et le modèle coûteux intervient en cas de problème. Cependant, celui-ci n’a rien résolu. Au cours de trois tours, gpt-4o a progressivement réduit le nombre de violations de huit à cinq, puis à quatre, sans jamais atteindre zéro, et a généré 918 tokens de sortie. Après le passage au modèle de raisonnement o4-mini, le problème a été résolu dès le premier tour, avec zéro violation, mais au prix de 3 886 tokens de sortie.

    A posteriori, cela semble logique. La tâche consiste en une satisfaction de contraintes, ce qui exige une recherche systématique. gpt-4o n’est pas significativement meilleur que gpt-4o-mini à cet égard, puisque les deux fonctionnent de la même manière et que l’un est simplement plus volumineux. L’écart de tokens n’est pas non plus fortuit, car la plupart de ces 3 886 tokens sont des tokens de raisonnement. Le coût lié à la réflexion apparaît dans le tableau des prix. Leçon générale : l’escalade ne devrait pas signifier un modèle plus cher, mais plutôt un modèle qui fonctionne différemment. Évaluez quel modèle aide le mieux à résoudre votre propre problème et n’imposez pas de suppositions.

    La exécution a finalement réussi, et le journal montre comment elle s’est déroulée :

    --- Ekip - tur 1/3 (gpt-4o-mini) ----------------------------------------
    [hakem] tur 1: GECERSIZ: 4 kural ihlali var.
    --- Ekip - tur 2/3 (gpt-4o-mini) ----------------------------------------
    [hakem] tur 2: GECERSIZ: 4 kural ihlali var.
    --- Ekip - tur 3/3 (gpt-4o-mini) ----------------------------------------
    [hakem] tur 3: GECERSIZ: 6 kural ihlali var.
    [karar] Takilma tespit edildi: Son 2 turda ihlal sayisi 4 seviyesinden
            asagi inmedi; ilerleme yok.
    
    --- Supervisor - tur 1/3 (o4-mini) --------------------------------------
    [hakem] supervisor tur 1: GECERLI: Cizelge butun kurallara uyuyor.
    

    Il n’y avait pas de script derrière cela. L’équipe s’est vraiment retrouvée bloquée, l’état de blocage a été mesuré, et le superviseur a résolu la tâche.

    La facture

    À la fin de l’étape quatre, les dépenses des deux modèles sont affichées côte à côte :

    Asama         Model        Girdi   Cikti  Maliyet $
    ------------  -----------  ------  -----  ---------
    ekip (3 tur)  gpt-4o-mini  16.566  2.290  0,00386
    supervisor    o4-mini       5.463  3.886  0,02311
    ------------  -----------  ------  -----  ---------
    TOPLAM                     22.029  6.176  0,02697
    

    Les trois tours effectués par l’équipe coûtent environ 0,0039 dollar, tandis que le superviseur en coûte près de 0,0231 dollar ; ainsi, l’escalade représente une seule ligne de coût équivalant à environ six fois l’effort total de l’équipe. C’est cette table qui justifie l’architecture choisie. Si l’on confie tout au superviseur, la facture est multipliée par six. Si l’on confie tout à l’équipe moins chère, le travail ne sera jamais terminé. La solution idéale se situe entre les deux, et la mesure est le seul moyen de la trouver.

    Points clés

    • Tant que vous demandez aux agents s’ils ont réussi, le système est fictif. Un arbitre déterministe constitue le fondement sur lequel repose toute l’architecture. Si votre problème ne comporte pas de côté vérifiable par machine, trouvez-en d’abord un.
    • Il ne suffit pas que un LLM audite un autre : l’auditeur crée ses propres hallucinations, ce qui double les coûts.
  • Un retour d’information correct est nécessaire mais insuffisant. Un petit modèle peut recevoir la bonne liste des violations et ne pas parvenir à converger, il est donc nécessaire d’avoir un mécanisme de mesure des progrès.
  • L’escalade comporte quatre éléments : un modèle qui fonctionne différemment, l’historique des échecs, le même cycle de validation déterministe et un message système qui décrit une méthode systématique.
  • Organisation du code

    L’expérience est divisée en quatre fichiers destinés à être exécutés dans l’ordre, chacun commençant par une note indiquant ce qu’il enseigne :

    01_tek_agent.py      AssistantAgent, run(), TaskResult
    02_ekip.py           RoundRobinGroupChat, max_turns, Console
    03_dogrulayici.py    tools=[...], reflect_on_tool_use, deterministik termination
    04_eskalasyon.py     dış döngü, takılma tespiti, eskalasyon paketi, maliyet defteri
    

    Ces tests n’ont pas besoin de clé API. Le ReplayChatCompletionClient d’AutoGen renvoie les réponses du modèle une par une, ce qui permet de vérifier gratuitement les deux hypothèses les plus risquées du projet. Les versions utilisées étaient autogen-agentchat 0,7.5 et Python 3,11. Le comportement des petits modèles varie d’une exécution à l’autre, et gpt-4o-mini se situe précisément au bord de ce problème, terminant parfois en quatre tours.