Module 6 — Délégation et supervision

Un agent qui ne sait pas répondre à sa propre tâche a deux voies possibles : produire une réponse approximative, ou passer la main. La délégation est ce qui permet la seconde. C'est une fonctionnalité puissante — elle rend l'équipe plus résiliente — mais mal maîtrisée elle produit les fameuses boucles de délégation où deux agents se renvoient indéfiniment le même problème.

Le mécanisme : allow_delegation et Delegate work to coworker

Un agent avec allow_delegation=True reçoit dans sa consigne système la description des autres agents de l'équipe et deux outils implicites : Delegate work to coworker et Ask question to coworker. Il peut donc, au cours de sa propre tâche, décider de :

• déléguer une sous-tâche à un autre agent, qui produit une réponse renvoyée à l'agent délégant ;
• poser une question à un autre agent, plus courte et plus ciblée qu'une délégation complète.

Cette mécanique s'aligne sur ce qu'une équipe humaine ferait naturellement : l'analyste bute sur une ambiguïté et demande au relecteur si le terme est cohérent avec le glossaire ; le rédacteur ne sait pas quelle priorité donner à une section et demande à l'analyste.

Quand la délégation est utile — et quand elle ne l'est pas

Ouvrir la délégation par défaut est une erreur. La règle est la suivante : la délégation est utile quand la tâche de l'agent contient une décision qui ne relève pas de son domaine. L'analyste peut avoir à trancher entre deux formulations françaises ; c'est le rôle du rédacteur, pas le sien, et une délégation est justifiée. Le rédacteur peut avoir à décider si une fonctionnalité est prioritaire ; c'est le rôle de l'analyste, pas le sien.

À l'inverse, la délégation est nuisible quand :

• l'agent délègue sa propre tâche entière parce qu'il n'a pas envie ou pas les moyens de la faire — signe d'un objectif mal formulé ;
• les agents ont des rôles trop proches et se renvoient la balle sans que la décision progresse ;
• un agent délègue à un autre qui ne dispose pas de l'information pour répondre, produisant une réponse creuse renvoyée telle quelle.

Le fait qu'un agent délègue sa tâche complète est presque toujours un signal que son objectif est trop flou (revoir le module 2). Aucun réglage de CrewAI ne compensera une définition d'agent qui ne donne pas de prise à l'exécution.

Les boucles de délégation, et comment les repérer

La pathologie la plus visible se manifeste ainsi : dans la trace verbose=True, vous voyez l'agent A appeler Delegate work to coworker(B), puis B renvoyer un « je pense que A devrait s'en occuper », puis A redéléguer à B avec une reformulation, jusqu'à ce que CrewAI épuise ses itérations. Deux causes classiques :

1. Objectifs identiques entre deux agents. Si le rédacteur et le relecteur ont tous les deux pour objectif « améliorer la qualité du texte », chacun renvoie à l'autre à chaque doute.
2. Aucun agent n'a l'autorité de conclure. Sans un rôle explicitement chargé de trancher, un désaccord persistant tourne en rond.

Les correctifs sont symétriques. Rendre les objectifs complémentaires plutôt que semblables ; nommer un responsable qui a le dernier mot ; et fixer une limite de délégation par étape via max_iter sur l'agent, qui coupe court aux boucles infinies.

Le rôle du responsable

Dans notre fil rouge, le quatrième agent est un responsable de la documentation. Sa fonction n'est pas d'écrire — il ne prend pas la plume — mais d'arbitrer en cas de désaccord. Sa définition ressemble à ceci :

responsable = Agent(
    role="Responsable éditorial",
    goal=(
        "Trancher les désaccords entre l'analyste, le rédacteur et le "
        "relecteur, et valider la cohérence globale de la documentation. "
        "Vous n'écrivez pas ; vous décidez."
    ),
    backstory=(
        "Vous êtes la ligne éditoriale incarnée. Vous préférez une "
        "position claire à un compromis mou. Quand deux personnes ne "
        "sont pas d'accord, vous choisissez, et vous justifiez en une "
        "phrase."
    ),
    llm=ChatOpenAI(model="gpt-4o", temperature=0.1),
    allow_delegation=False,
)

Deux détails critiques. D'abord, le responsable ne délègue pas (allow_delegation=False) : c'est le terminus de toute chaîne de délégation. Ensuite, son objectif dit explicitement « vous décidez » : sans cette autorité, le responsable renvoie à son tour, et la boucle se referme sur trois participants au lieu de deux.

En processus séquentiel, on place la tâche du responsable à la fin, avec la sortie des trois autres tâches en context. En processus hiérarchique, le responsable est le gestionnaire — c'est ce que CrewAI attend quand il vous demande un manager_llm.

Limiter les itérations pour couper court

Chaque agent a un paramètre max_iter (par défaut 25) qui borne le nombre de tours de boucle interne. Un agent qui atteint cette limite conclut avec la meilleure réponse à sa disposition. Baisser cette valeur à 5 ou 10 pendant le développement permet de détecter tôt les boucles improductives, plutôt que de les découvrir après cinq minutes d'exécution.

La délégation n'est pas un remède, c'est un mécanisme

Autoriser la délégation ne rend pas une équipe intelligente. Elle amplifie ce que vous avez déjà : des agents bien définis coopèrent, des agents mal définis se renvoient la balle. Toujours corriger la définition avant d'ouvrir la délégation, jamais l'inverse.

En résumé

• allow_delegation=True donne à l'agent deux outils implicites : déléguer et poser une question à un pair.
• La délégation est utile pour les décisions hors domaine ; elle est nuisible quand deux agents ont des rôles trop proches ou qu'aucun n'a l'autorité de conclure.
• Les boucles de délégation viennent d'objectifs identiques ou d'une absence de responsable ; on les casse en rendant les objectifs complémentaires et en nommant un arbitre qui ne délègue pas.
• max_iter borne la boucle interne d'un agent ; en développement, une valeur basse fait remonter les boucles improductives avant qu'elles ne coûtent cher.

Module suivant : la mémoire commune et le passage de contexte entre tâches.