Swarm / Handoffs
Aussi appelé : handoff pattern, agent handoffs, routines and handoffs (cookbook OpenAI), decentralized pattern (guide OpenAI), network architecture (LangGraph), handoff orchestration (Microsoft), agent transfer (Google ADK)
Intention
Plusieurs agents spécialisés partagent une même conversation, et un seul d'entre eux est actif à un instant donné. L'agent actif répond lui-même à l'utilisateur et, quand une demande sort de son domaine, il passe la main, avec la conversation, à un pair mieux placé en appelant un outil tel que transfer_to_refunds. Le message suivant de l'utilisateur va directement à l'agent actif, sans étape de routage.
Problème
Vous développez le chat de support d'une compagnie aérienne. Les clients posent des questions sur les changements de siège, l'état des vols, les règles bagages, les annulations et les indemnisations, souvent plusieurs à la fois dans la même conversation : « Mon vol a été annulé. Puis-je choisir un siège sur le nouveau, et ai-je droit à une indemnisation ? »
La première version est un seul agent, avec toutes les règles dans son prompt et 40 outils. Il appelle l'outil de remboursement pendant un changement de siège, mélange les règles, et chaque règle est payée à chaque tour. Dans l'expérience tau-bench de LangChain, le score d'un agent unique chute nettement dès que deux domaines d'outils sans rapport ou plus sont ajoutés à son contexte. Vous répartissez donc le travail entre des spécialistes et placez un superviseur devant eux, ce qui crée de nouveaux problèmes :
- Chaque message paie un détour. Le superviseur lit chaque message, appelle un spécialiste, puis rédige la réponse. Dans l'exemple de la documentation de LangChain, une demande répétée coûte 8 appels de modèle sur deux tours avec un superviseur et des sous-agents, contre 5 avec des handoffs.
- Les réponses sont reformulées. Le superviseur réécrit ce que le spécialiste a dit. LangChain attribue l'essentiel de l'écart entre son superviseur et son swarm à cette couche de « traduction ».
- Les spécialistes ne peuvent pas passer le client à un autre. L'agent de choix du siège voit que ce client veut maintenant une indemnisation, mais il ne peut que rendre compte au centre. Il ne peut pas confier le client à l'agent des remboursements.
Solution
Supprimez le centre et laissez les spécialistes se passer la conversation. Chaque agent a ses propres instructions, son propre petit jeu d'outils et une liste de pairs vers lesquels il peut transférer. Chaque transfert autorisé est exposé au modèle comme un outil ordinaire : le modèle décide quand faire appel à un collègue de la même façon qu'il décide quand appeler n'importe quel outil.
- L'agent d'entrée reçoit le premier message. Triage, qui n'a aucun outil de réservation, lit « mon vol a été annulé, un siège sur le nouveau, une indemnisation ? » et appelle
transfer_to_seat_bookingavec une courte justification. - Le runtime change d'agent actif. Il enregistre un résultat d'outil (« Transféré à Choix du siège ») pour que l'historique reste bien formé, décide de ce que le destinataire voit de l'historique et définit l'agent actif. Le prompt système de Choix du siège remplace celui de Triage.
- Le destinataire poursuit dans le même tour. Choix du siège demande le numéro de réservation. Le tour se termine quand un agent répond sans appeler d'outil, et le runtime renvoie les nouveaux messages et le nom de l'agent actif.
- Le message suivant saute le routage. Le client répond « ABC123, siège 12A ». Le code l'envoie directement à Choix du siège, qui appelle
update_seatet confirme. - Un pair passe la main directement. Choix du siège ne gère pas les indemnisations : il appelle
transfer_to_refundsavec un résumé d'une ligne. Remboursements propose d'ouvrir un dossier d'indemnisation, dans le même tour.
Qui décide du déroulement : le développeur décide quels agents existent et quels transferts sont autorisés (le graphe de handoffs). Le modèle de l'agent actif décide s'il transfère, quand et à qui, parmi les cibles autorisées. Le runtime décide du contexte transmis et fait respecter les limites. Aucun agent ne voit le système entier : le parcours global émerge de décisions locales du type « ce n'est pas pour moi ».
Le voisin le plus proche est le Supervisor. Là, le contrôle revient à un agent central après chaque étape d'un worker, et seul cet agent parle à l'utilisateur. Dans un système de handoffs, le destinataire prend le relais et reste actif jusqu'à ce qu'il passe la main à son tour, et il parle directement à l'utilisateur.
Analogie
Le cookbook d'OpenAI, qui a nommé le pattern, prend l'exemple d'un appel téléphonique : on vous transfère vers un autre service, et la personne qui décroche connaît déjà votre problème. Les services sont les agents, le bouton de transfert est l'outil de handoff, et les notes d'appel à l'écran sont l'historique partagé. Quand vous rappelez pour le même problème, vous retombez sur le service auquel on vous avait laissé.
L'analogie s'arrête aux boucles. Un vrai centre d'appels a un responsable qui remarque qu'un appelant a été renvoyé quatre fois entre deux guichets. Un système de handoffs n'a personne pour ça : c'est à vous d'intégrer ce contrôle au runtime.
Structure
- Agents (pairs). Chacun possède un domaine : des instructions, quelques outils métier, un modèle et la liste des agents vers lesquels il peut transférer. Aucun n'est le chef d'un autre. Triage est l'agent d'entrée qui reçoit le premier message.
- Outils de handoff. Un outil généré par cible autorisée, généralement nommé
transfer_to_<agent>. Le nom et la description sont le seul signal dont le modèle dispose pour choisir une cible : ils font donc partie du prompt. Des arguments facultatifs transportent une justification ou un résumé. - Agent actif. Le seul agent qui parle au client. Son nom est conservé entre les tours de l'utilisateur, pour que le message suivant lui parvienne directement.
- Boucle d'exécution. Appelle l'agent actif, exécute les outils, détecte un handoff, écrit le résultat d'outil correspondant, change d'agent, applique les filtres d'historique et fait respecter les plafonds de tours et de handoffs.
- État partagé. L'historique des messages que chaque agent lit (complet, filtré ou résumé selon le handoff), le pointeur vers l'agent actif et un objet de contexte qui contient les faits durables, comme le numéro de réservation.
- Issue de secours. Un humain, ou un retour vers Triage. Chaque agent a besoin d'au moins une sortie, pour qu'un client ne reste jamais bloqué avec un agent qui ne peut pas l'aider.
Générateur de prompt
Décrivez les agents, ce que chacun gère et ne gère pas, et à qui il peut transférer. Le générateur écrit un préfixe commun, un prompt système par agent, les descriptions des outils de handoff et une courte checklist pour le runtime. Les prompts conviennent à tout framework doté d'outils de handoff (OpenAI Agents SDK, langgraph-swarm, AutoGen Swarm, Microsoft Agent Framework, Strands) ; la checklist est destinée à votre code. Laissez « Peut transférer à » vide pour autoriser tous les autres agents.
Prompt généré
Le texte surligné vient du formulaire. Le texte [entre crochets] reste à remplir.
La plupart des bugs de handoff viennent d'un agent qui continue de répondre alors que le sujet a quitté son domaine, simplement parce qu'il est toujours actif. Une liste explicite de ce que chaque agent ne gère pas, associée au transfert à utiliser dans chaque cas, est ce qui fait lâcher prise à l'agent. Rédigez aussi les descriptions des outils de handoff comme des règles de routage : les valeurs par défaut des frameworks (« Handoff to the X agent to handle the request » dans l'Agents SDK) ne disent rien de quand les utiliser.
Quand l'utiliser
À utiliser quand
- La conversation est multi-tours, face à l'utilisateur, et son sujet dérive. Support, réservation, onboarding et helpdesk informatique, où le bon expert change au fil de la conversation.
- Le bon spécialiste n'apparaît qu'en cours de conversation. S'il est impossible de le déterminer dès le premier message, un classifieur à coup unique se trompera souvent.
- Les spécialistes doivent répondre directement à l'utilisateur. Aucun centre ne reformule leurs réponses, et un message de suivi va au spécialiste actif sans appel de routage.
- Les domaines sont nets et ne se chevauchent pas. Un modèle doit pouvoir distinguer « changement de siège » et « remboursement » à partir d'une description d'outil d'une ligne.
- Vous voulez faire grandir le système un spécialiste à la fois. Ajouter un agent, c'est un prompt, ses outils et quelques arêtes.
À éviter quand
- Le bon interlocuteur est évident dès la première entrée. Classez une fois avec Routing ; si les règles sont déterministes, routez dans le code.
- La tâche demande de travailler sur plusieurs domaines à la fois. Les handoffs font tourner un seul agent à la fois. Dans l'exemple de la documentation de LangChain, une demande multi-domaines coûte 7 appels ou plus et environ 14K tokens avec des handoffs, contre 5 appels et environ 9K tokens avec des sous-agents ou un routeur. Utilisez Parallelization ou Orchestrator–Workers.
- Un seul agent doit être responsable de la réponse finale ou appliquer les règles en un seul endroit. Utilisez un Supervisor avec des agents comme outils.
- Les sous-agents sont tiers ou opaques. Les pairs doivent connaître les noms et les périmètres les uns des autres, et LangChain déconseille de laisser un agent externe actif face à votre utilisateur.
- Une erreur d'aiguillage ou une boucle coûterait cher. Azure cite les boucles de handoff infinies et le routage imprévisible comme les écueils typiques du pattern.
- Un seul agent avec quelques outils fonctionne déjà. Le guide pratique d'OpenAI recommande de s'en tenir à un seul agent ReAct jusqu'à ce que la logique du prompt ou la surcharge d'outils impose une séparation (vérifié uniquement via un résumé secondaire du guide).
Mise en œuvre
- Ne séparez que lorsqu'un agent unique pose problème. Découpez alors les agents selon les frontières de la conversation : chacun doit pouvoir tenir le chat tant que le sujet reste dans son domaine. Un spécialiste qui se contente de calculer un sous-résultat et de le renvoyer est un agent-outil, qui a sa place dans un Supervisor.
- Dessinez le graphe de handoffs. Commencez en étoile : Triage vers chaque spécialiste, chaque spécialiste vers Triage. N'ajoutez des liens directs entre pairs que là où de vraies conversations passent, par exemple du choix du siège vers les remboursements. Donnez une sortie à chaque agent.
- Écrivez des instructions avec un périmètre et des règles de sortie. Ce que l'agent gère, ce qu'il ne gère pas et quel transfert utiliser pour chaque cas hors périmètre. Ajoutez un préfixe commun qui indique que l'agent fait partie d'un ensemble, que le destinataire voit la conversation et qu'il ne faut rien faire répéter à l'utilisateur.
- Remplacez les descriptions par défaut des outils de handoff. Faites de chacune une règle de routage. Demandez un argument
reasonousummaryet validez-le dans le code avant le transfert. - Décidez du contexte transmis sur chaque arête. L'historique complet est la valeur par défaut dans la plupart des frameworks. Retirez les échanges d'outils quand le destinataire a d'autres outils, résumez les longues conversations, ou ne transmettez qu'un résumé quand l'émetteur a fait beaucoup de travail interne. Gardez chaque appel d'outil avec son résultat, sinon la plupart des API de chat rejettent l'historique.
- Placez les faits durables dans un objet de contexte. La référence de réservation et l'identité vérifiée ont leur place dans un état structuré que les outils lisent, pour qu'un historique filtré ou résumé ne puisse pas les perdre. L'exemple de service client d'OpenAI définit le numéro de vol dans un hook
on_handoff, et l'outil de siège vérifie qu'il est présent. - Conservez l'agent actif et l'historique entre les tours. Sans cela, chaque message repart de Triage et vous perdez le principal avantage du pattern.
- Ajoutez des limites. Un plafond de tours, un plafond de handoffs, la détection des allers-retours et des délais d'expiration. Désactivez les appels d'outils parallèles pour que le modèle ne puisse pas demander deux transferts à la fois.
- Placez des garde-fous sur chaque agent qui parle à l'utilisateur ou appelle des outils risqués. Ne contrôler que l'agent d'entrée laisse les autres sans protection.
- Évaluez par agent, par transition, puis de bout en bout. Pour chaque arête, rassemblez des cas qui doivent la déclencher et des quasi-cas qui ne le doivent pas, et produisez une matrice de confusion entre cible attendue et cible réelle. Lancez ensuite des scénarios multi-tours avec un utilisateur simulé qui change de sujet en cours de conversation. Journalisez chaque handoff avec l'émetteur, le destinataire, la justification et l'indice du tour.
| Framework | Forme d'un handoff | Agent actif d'un tour à l'autre |
|---|---|---|
| OpenAI Swarm | Une fonction renvoie un Agent. Expérimental et pédagogique, remplacé par l'Agents SDK. | L'appelant renvoie response.agent |
| OpenAI Agents SDK | Agent(handoffs=[...]), handoff() avec input_type, input_filter, on_handoff ; outil nommé transfer_to_<agent> | result.last_agent, ou une session |
| LangGraph (langgraph-swarm) | create_swarm, create_handoff_tool ; l'outil renvoie un Command(goto=...) | active_agent dans l'état sauvegardé par checkpoint |
| AutoGen AgentChat | Équipe Swarm ; un appel d'outil produit un HandoffMessage | Reprise avec un HandoffMessage adressé à cet agent |
| Microsoft Agent Framework | HandoffBuilder avec with_start_agent et add_handoff ; outils de handoff injectés | Par défaut, la réponse revient à l'agent précédent |
| Semantic Kernel | HandoffOrchestration avec des arêtes déclarées dans OrchestrationHandoffs (expérimental) | Géré par le runtime |
| AWS Strands | Swarm avec un outil handoff_to_agent (Python) ou une sortie structurée (TypeScript) | Orienté tâche ; interruption et reprise |
| Google ADK | transfer_to_agent(agent_name=...) entre un agent et ses sub_agents | Un sous-agent en mode chat garde la main jusqu'à ce qu'il transfère |
Les valeurs par défaut diffèrent sur des points qui comptent. L'Agents SDK plafonne une exécution à 10 tours par défaut (lu dans son code source en novembre 2026) et n'exécute que le premier de plusieurs handoffs dans une même réponse ; Swarm n'a pas de plafond de tours par défaut et garde le dernier. Strands fixe par défaut 20 handoffs et 20 itérations, avec la détection des allers-retours désactivée. Dans l'Agents SDK, les garde-fous d'entrée ne s'exécutent que pour le premier agent, et les garde-fous d'outils ne s'appliquent pas aux appels de handoff.
Mise en garde. Ces API évoluent vite. Le nest_handoff_history de l'Agents SDK est une bêta à activer explicitement, l'orchestration de Semantic Kernel et le mode autonome d'Agent Framework sont marqués expérimentaux, et la documentation de Google ADK a été réorganisée récemment. AutoGen serait passé en mode maintenance au profit de Microsoft Agent Framework, mais l'information vient de la presse et n'est pas vérifiée. Les frameworks ne s'accordent pas non plus sur le mot : OpenAI, LangGraph et AutoGen appellent « swarm » le handoff conversationnel, Strands un relais de tâche autonome.
Variantes
Triage central en étoile
Un agent de triage sans outils métier envoie les utilisateurs vers les spécialistes, et chaque spécialiste ne peut revenir qu'au triage. La plupart des exemples officiels (OpenAI, Semantic Kernel, Agent Framework) ont cette forme. Cela ressemble à un routeur, mais le triage est un agent à part entière qui peut poser des questions avant de transférer, et le spécialiste garde l'utilisateur ensuite.
Maillage complet
Chaque agent peut transférer à tous les autres. C'est ce que LangChain a évalué sous le nom de « swarm ». C'est le plus simple à configurer et le plus difficile à garder sans boucles, et le prompt de chaque agent doit décrire tous les autres.
Graphe de handoffs contraint
Seules les arêtes déclarées sont autorisées : OrchestrationHandoffs dans Semantic Kernel, add_handoff dans Agent Framework, disallow_transfer_to_peers dans Google ADK. Choisissez-le quand certains transferts ne doivent jamais avoir lieu. Dans Agent Framework, chaque agent reçoit quand même l'historique diffusé ; les arêtes ne déterminent que qui peut prendre le relais.
Agent unique en machine à états
Un seul agent dont le prompt et les outils changent selon une variable d'état comme current_step, que les outils mettent à jour. LangChain le recommande dans la plupart des cas, et ne conseille des sous-graphes d'agents séparés que lorsque les agents ont besoin de leur propre fonctionnement interne. Il convient aux séquences imposées, comme recueillir un numéro de garantie avant un remboursement.
Relais de tâche autonome
Pas d'utilisateur dans la boucle : les agents se passent une tâche (chercheur, architecte, développeur, relecteur dans l'exemple de Strands) jusqu'à ce que l'un d'eux réponde sans passer la main. C'est ce que Strands appelle un swarm. C'est plus proche de l'orchestration, et son principal risque est l'emballement des boucles : il lui faut des plafonds stricts et des délais d'expiration.
Handoff avec charge utile typée ou hooks
Le transfert transporte des arguments validés (justification, priorité, résumé) et déclenche des effets de bord comme récupérer la commande ou ouvrir un ticket. Validez avant d'agir, et gardez les hooks idempotents.
Handoff et agents comme outils
Triage passe la main à un spécialiste, et le spécialiste appelle d'autres agents comme outils pour des sous-tâches précises. Les handoffs décident de qui tient la conversation ; les appels d'outils décident de qui en calcule une partie.
Avantages et inconvénients
Avantages
- Moins d'appels de modèle par tour qu'avec un superviseur : l'exemple de la documentation de LangChain compte 3 appels contre 4 pour une demande ponctuelle, et 5 contre 8 sur deux tours.
- Les spécialistes répondent directement à l'utilisateur, donc rien ne se perd en reformulation. Dans l'étude tau-bench de LangChain (GPT-4o, un seul jeu de données), le swarm obtient un score légèrement supérieur au superviseur et consomme moins de tokens.
- Chaque agent ne voit que son propre prompt et ses propres outils, ce qui garde les contextes petits.
- Les messages de suivi vont directement au spécialiste actif, sans appel de routage.
- Une transcription partagée unique se lit facilement pendant le débogage.
Inconvénients
- Pas de contrôle central : les parcours émergent de décisions locales et sont difficiles à prévoir.
- Les boucles et les allers-retours entre agents exigent des plafonds et une détection explicites.
- Strictement séquentiel, un agent à la fois, donc les demandes multi-domaines coûtent plus cher.
- Les agents doivent connaître leurs pairs ; dans un maillage, ajouter un agent oblige à modifier les prompts ou les listes d'outils des autres.
- Les garde-fous et les autorisations doivent être appliqués sur chaque agent, ce qui est facile à rater.
- L'historique partagé grossit à chaque saut, sauf si vous le filtrez ou le compactez.
Les preuves de qualité sont minces. Les seuls chiffres en confrontation directe viennent du benchmark de LangChain lui-même, qui ne montre ses scores que sous forme de graphiques et ne nomme pas sa métrique. LangChain a aussi amélioré son superviseur de près de 50 % avec trois corrections d'implémentation : considérez « le swarm bat le superviseur » comme provisoire. Les nombres d'appels ci-dessus sont des exemples chiffrés de documentation, pas des mesures de benchmark.
Modes de défaillance
- Allers-retours et boucles de handoff
-
Choix du siège transfère à Remboursements, qui renvoie la main, plusieurs fois dans un même tour. Le coût s'envole et l'exécution se termine sur une erreur de plafond de tours.
Parade : des plafonds stricts sur les tours et les handoffs, une vérification des handoffs répétés (si les N derniers transferts impliquent moins de M agents distincts, arrêtez), des descriptions de périmètre qui ne se chevauchent pas, et une règle qui interdit de rendre la main à l'agent dont on vient de la recevoir, sauf si l'utilisateur a dit quelque chose de nouveau.
- Mauvais aiguillage qui colle
-
Le client pose une question d'indemnisation, et Choix du siège essaie d'y répondre parce qu'il est toujours l'agent actif.
Parade : une liste explicite « vous ne gérez pas » dans chaque prompt et un
transfer_to_triagelarge pour tout le reste. Si les utilisateurs changent brusquement de sujet, faites plutôt passer chaque nouveau message par Triage (enable_return_to_previous(False)dans Agent Framework), au prix d'un appel par tour. Ajoutez des évaluations sur des demandes hors périmètre pendant qu'un spécialiste est actif. - Handoff prématuré
-
Triage transfère avant d'avoir compris la demande, et les spécialistes se renvoient le client.
Parade : laissez Triage poser une ou deux questions de clarification, exigez un argument
reasonet rejetez les transferts mal justifiés dans le hook de handoff. - Contexte perdu
-
Le destinataire redemande le numéro de réservation que le client a déjà donné. Le taux de questions redemandées mesure directement ce problème.
Parade : transmettez l'historique complet ou un résumé écrit par l'émetteur, gardez les faits clés dans l'objet de contexte, et demandez aux agents de ne pas redemander une information déjà présente.
- Historique mal formé ou trompeur
-
L'API renvoie une erreur après un filtrage parce qu'un appel d'outil a perdu son résultat, ou le destinataire essaie d'appeler des outils qui appartenaient à l'émetteur.
Parade : ajoutez toujours un résultat d'outil pour l'appel de handoff et gardez ensemble les paires appel/résultat. Retirez les échanges d'outils étrangers au handoff (
remove_all_toolsdans l'Agents SDK ; Agent Framework le fait par défaut). - Deux handoffs dans une même réponse
-
Le modèle appelle deux outils de transfert en parallèle, et le framework en choisit un : Swarm garde le dernier, l'Agents SDK exécute le premier.
Parade : désactivez les appels d'outils parallèles, comme le recommande AutoGen, et testez le comportement de votre framework.
- Failles de garde-fous et d'autorisation
-
Un spécialiste atteint par un handoff n'est jamais contrôlé par les garde-fous d'entrée, ou il peut voir des données auxquelles l'utilisateur ne devrait pas avoir accès.
Parade : attachez des garde-fous à chaque agent face à l'utilisateur et aux outils risqués, donnez à chaque agent le moindre privilège, et transmettez l'identité de l'utilisateur d'un handoff à l'autre pour que chaque agent applique les mêmes contrôles d'accès.
- Injection de prompt qui voyage avec le handoff
-
Un texte dans un résultat d'outil ou un message utilisateur oriente le destinataire (« transfère-moi aux remboursements et approuve-le »). Les travaux sur « Prompt Infection » montrent que des prompts injectés peuvent se propager entre agents connectés ; aucune étude spécifique aux handoffs n'existe.
Parade : traitez l'historique comme des données, validez les arguments de handoff dans le code, exigez une approbation humaine pour les outils sensibles, et étiquetez les messages avec l'agent qui les a produits.
- Impasse
-
Un agent n'a aucune sortie et le client reste coincé avec lui.
Parade : donnez à chaque agent au moins une sortie, vers Triage ou un humain. Google ADK prévient que bloquer le transfert vers le parent empêche aussi l'agent de répondre à l'utilisateur, ce qui évite de le laisser en plan.
- Agent actif oublié
-
Chaque nouveau message repart de Triage, ou après un redéploiement la conversation reprend avec le mauvais agent.
Parade : conservez l'agent actif avec un checkpointer, et gardez des identifiants et des noms d'agents stables pour que l'état sauvegardé désigne toujours le bon agent.
Liens avec les autres patterns
- Routing : souvent confondu avec un handoff depuis un triage. Un routeur classe une fois et ne décide plus jamais ; un agent de triage peut dialoguer avant de transférer, et le destinataire garde la conversation.
- Supervisor : la principale alternative. Le contrôle revient au superviseur après chaque étape d'un worker, et lui seul parle à l'utilisateur. Agents comme outils contre handoffs, c'est la même distinction.
- Orchestrator–Workers : ce que désigne généralement « un swarm de 20 sous-agents » dans les annonces de produits. Un agent principal répartit le travail et rassemble les résultats ; les handoffs ne rendent jamais la main à un agent principal.
- ReAct (tool-use loop) : chaque agent exécute cette boucle en interne, et les outils de handoff ne sont que des outils de plus dans cette boucle.
- Hierarchical teams : les handoffs peuvent avoir lieu au sein d'une équipe à n'importe quel niveau ; LangGraph permet à un agent d'un sous-graphe de passer la main dans le graphe parent.
- Group Chat : un sélecteur extérieur aux agents choisit chaque intervenant. Le Swarm d'AutoGen est un group chat dont l'intervenant suivant est donné par le dernier message de handoff.
- Blackboard : l'« intelligence en essaim » (des agents qui se coordonnent par un environnement partagé, comme des fourmis) relève de ce pattern-là, pas de celui-ci.
- Human-in-the-Loop : un humain est une cible de handoff valable, et les validations obligatoires sur les outils sensibles fonctionnent dans un système de handoffs.
- Parallelization : le meilleur choix quand une demande couvre plusieurs domaines qui peuvent être traités en même temps.
Pour aller plus loin
- Orchestrating Agents: Routines and Handoffs (OpenAI Cookbook, 2024, en anglais) : la recette qui a nommé le pattern, avec une boucle d'exécution minimale où un outil qui renvoie un agent constitue le handoff.
- Handoffs (documentation de l'OpenAI Agents SDK) : les paramètres de handoff, les filtres d'entrée, les charges utiles typées, et les garde-fous qui s'appliquent ou non.
- langgraph-swarm (LangChain, GitHub) : les outils de handoff sous forme de commandes de graphe, le pointeur vers l'agent actif et la raison pour laquelle un checkpointer est nécessaire.
- Benchmarking Multi-Agent Architectures (blog LangChain, 2025) : la comparaison swarm, superviseur et agent unique sur tau-bench, et ses limites.
- AI agent orchestration patterns (Azure Architecture Center) : quand utiliser ou éviter le handoff, ses écueils et des conseils de sécurité.
- Swarm (documentation de Strands Agents) : la lecture « relais de tâche » de « swarm », avec plafonds de handoffs, délais d'expiration et détection des allers-retours.