À mesure que les agents entreprennent des tâches plus ambitieuses, ils rencontrent des difficultés à :
- Effectuer un travail fiable à grande échelle
- Gérer leur propre contexte
Nous avons expérimenté une approche pour relever ces défis sous la forme de ce que nous appelons des sous-agents dynamiques : au lieu de déléguer des tâches à des sous-agents via des appels d'outils génériques, l'agent écrit un court script qui pilote l'exécution des sous-agents. Cela permet aux modèles de s'appuyer sur des schémas de code qu'ils maîtrisent bien (comme les boucles, les branchements ou la concurrence) pour écrire une logique d'orchestration adaptée à la tâche.
Pourquoi des sous-agents dynamiques ?
Deep Agents prend déjà en charge les sous-agents. Ils isolent le contexte, permettent à l'agent principal de déléguer des unités de travail discrètes et maintiennent les résultats intermédiaires hors de la fenêtre de contexte principale. Alors, pourquoi avons-nous besoin de sous-agents dynamiques ?
Avec les sous-agents normaux, ils sont appelés un par un, par le modèle principal qui les invoque directement. Cela fonctionne à petite échelle. Cela se dégrade lorsque vous devez générer des centaines de sous-agents, ou lorsque la logique d'orchestration est conditionnelle ou en plusieurs phases.
Les sous-agents dynamiques résolvent ce problème grâce à une orchestration programmatique. Au lieu d'effectuer des appels d'outils tour à tour, l'agent écrit un court script qui orchestre et appelle les sous-agents, et l'exécute dans un interpréteur léger.
L'exemple canonique : un sous-agent par page d'un document de 300 pages. Plutôt que d'appeler l'outil sous-agent 300 fois, l'agent écrit une boucle :
1const results = await Promise.all(pages.map(page =>2 task({ description: `Résumer la page ${page.number}`, subagentType: "summarizer" })3));
Cela débloque deux choses qu'une orchestration basée sur des appels d'outils ne peut pas fournir de manière fiable :
Couverture déterministe à grande échelle. Sans structure, les agents prennent des décisions subjectives sur le périmètre, en examinant 75 éléments sur 500 et en considérant le travail comme terminé. Une boucle de répartition ne le fait pas. La couverture devient une garantie structurelle, et non un problème d'ingénierie de prompt.
Orchestration complexe fiable. Écrire l'orchestration sous forme de code est plus fiable que de faire reproduire au modèle une séquence d'appels d'outils, en particulier pour le fan-out + synthèse, les pipelines multi-phases ou les branchements conditionnels.
C'est la même idée que celle derrière les workflows dans Claude Code et les Recursive Language Models (RLMs) : un modèle écrit du code, et ce code répartit davantage d'agents.
Démarrage rapide
Les sous-agents dynamiques nécessitent deux choses : des sous-agents pour répartir le travail, et un interpréteur de code : un environnement d'exécution sécurisé et léger où le modèle écrit et exécute le code d'orchestration. Deep Agents inclut un interpréteur de code optionnel basé sur QuickJS. Pour l'utiliser, installez le paquet middleware QuickJS, puis passez CodeInterpreterMiddleware via l'argument middleware sur create_deep_agent.
1pip install -U "deepagents[quickjs]"
1from deepagents import create_deep_agent2from langchain_quickjs import CodeInterpreterMiddleware34agent = create_deep_agent(5 model="openai:gpt-5.5",6 middleware=[CodeInterpreterMiddleware()],7)
Deep Agents est livré avec un sous-agent généraliste intégré, il existe donc déjà un profil de sous-agent général qui peut être utilisé dans les workflows. Pour des workflows spécialisés, configurez des sous-agents personnalisés avec leurs propres noms, descriptions et prompts système : les noms et descriptions sont la façon dont l'agent sait quel rôle utiliser.
Pour déclencher des sous-agents dynamiques, invitez votre agent avec le mot "workflow", comme ceci :
1result = await agent.ainvoke({2 "messages": [{"role": "user", "content": "Exécute un workflow qui examine chaque fichier dans src/routes/ et résume les principaux risques."}]3})
Utilisation avec un agent de codage
Le moyen le plus rapide d'essayer les sous-agents dynamiques est d'utiliser dcode, notre agent de codage en terminal construit avec un Deep Agent. Il est livré avec l'interpréteur de code activé, donc il n'y a rien à configurer — les sous-agents dynamiques fonctionnent immédiatement.
Installation
1curl -LsSf https://langch.in/dcode | bash
Exécution
1dcode
Pour déclencher des sous-agents dynamiques, demandez simplement un "workflow". Au lieu de s'acharner sur le travail lui-même, ou d'essayer de gérer les fan-outs de sous-agents avec son outil de tâche natif, l'agent écrit un script d'orchestration qui appelle la fonction globale task() intégrée et l'exécute dans l'interpréteur de code. Par exemple : "exécute un workflow pour examiner chaque fichier dans src/ à la recherche d'injections SQL."
Au fur et à mesure que les sous-agents sont générés, dcode les affiche en direct dans le panneau des sous-agents dynamiques, regroupés en phases par répartition.
Vous pouvez essayer cela plus rapidement avec dcode, mais vous pouvez également l'utiliser dans l'outil de votre choix via ACP (comme Zed).
Comment ça fonctionne
L'agent reçoit un outil d'évaluation. Il écrit du JavaScript qui s'exécute de manière sécurisée dans l'interpréteur. Lorsque des sous-agents sont configurés, l'interpréteur expose une fonction globale task() intégrée qui les répartit à partir du code. En fonction de la tâche à accomplir, le modèle écrit un code différent — une boucle, une branche, un Promise.all — et l'interpréteur l'exécute de manière déterministe.
task() prend une description, un subagentType et un responseSchema optionnel — lorsqu'il est fourni, le résultat est déjà un objet typé, prêt à être filtré ou passé à l'étape suivante.
1const result = await task({2 description: "Examiner src/auth/login.ts pour les problèmes de sécurité.",3 subagentType: "reviewer",4 responseSchema: {5 type: "object",6 properties: {7 severity: { type: "string", enum: ["high", "medium", "low"] },8 issues: { type: "array", items: { type: "string" } },9 },10 },11});1213const critical = result.severity === "high" ? result.issues : [];14critical; // le modèle voit la dernière ligne
Pour en savoir plus, consultez Sous-agents programmatiques et Interpréteurs dans la documentation.
Schémas d'orchestration courants
Les workflows dynamiques d'Anthropic ont popularisé un ensemble de schémas d'orchestration pour le travail parallèle des agents. Ce ne sont pas des fonctionnalités que vous activez. Ce sont des formes qui émergent naturellement du travail, et l'agent s'installe dans une forme différente à mesure que la tâche change. Le tableau ci-dessous associe chaque forme au type de travail auquel elle correspond.
Ci-dessous, nous allons voir comment chacun fonctionne dans Deep Agents, avec des traces en direct. Nous avons également préparé une vidéo expliquant ces six schémas, que vous pouvez consulter ici.
Classifier et agir
Les éléments sont d'abord classifiés, puis chaque élément est traité par un sous-agent spécialisé en fonction de sa classification. Cela permet de traiter des entrées mixtes où différents éléments nécessitent une expertise différente.
Cas d'utilisation : Triage des tickets de support, journaux d'erreurs, retours utilisateurs, ou tout lot d'éléments nécessitant un traitement différent selon leur type.
Exemple : Triage d'un backlog de tickets de support. L'agent lit les tickets et classe chacun comme un bug, une demande de fonctionnalité ou une question. Les bugs vont à un enquêteur de bugs, les demandes de fonctionnalités à un analyste de fonctionnalités, et les questions à un répondant de support. Le résultat est un résumé regroupé par catégorie.
Voir la trace ici.
Fan-out et synthèse
L'agent répartit le même type de travail sur de nombreux éléments en parallèle, puis combine les résultats.
Cas d'utilisation : Revue de code dans un répertoire, analyse d'un lot de documents, traitement de fichiers journaux, exécution de la même vérification sur plusieurs services.
Exemple : Une revue de sécurité par fichier dans une arborescence source. L'agent découvre tous les fichiers TypeScript sous src/ et répartit un réviseur de sécurité par fichier en parallèle. Il fusionne ensuite les résultats en un seul rapport priorisé avec des niveaux de gravité et les lignes à modifier.
Voir la trace ici.
Vérification contradictoire
Un schéma en deux passes. La première passe produit des résultats. La seconde passe envoie chaque résultat à des vérificateurs indépendants, et seuls les résultats qui survivent à l'accord sont conservés. Cela réduit les faux positifs lorsque la confiance est plus importante que la vitesse.
Cas d'utilisation : Audits de sécurité où les faux positifs sont coûteux, contrôles de conformité, toute revue où vous avez besoin d'une grande confiance dans les résultats.
Exemple : Un audit de sécurité où les faux positifs sont inacceptables. Un auditeur jette un large filet pour les vulnérabilités potentielles, puis chaque résultat est remis à un vérificateur indépendant qui lit le code à nouveau et renvoie un verdict CONFIRMÉ ou RÉFUTÉ. Seuls les résultats confirmés survivent dans le rapport final.
Voir la trace ici.
Générer et filtrer
Plusieurs sous-agents génèrent des solutions indépendantes au même problème. L'agent compare, note et filtre les résultats dans le code, en ne gardant que les meilleurs.
Cas d'utilisation : Propositions d'architecture, stratégies de refactorisation, variations de contenu, toute tâche où l'exploration de plusieurs options avant de s'engager produit un meilleur résultat.
Exemple : Refontes concurrentes d'un limiteur de débit, classées. L'agent a un architecte pour produire plusieurs refontes indépendantes de rate-limiter.ts, chacune écrite dans son propre fichier pour qu'elles ne s'écrasent pas mutuellement. Il les note ensuite sur la correction sous charge, le support multi-instance et la complexité. La plus forte gagne, avec une justification.
Voir la trace ici.
Tournoi
Les variantes sont comparées en tête-à-tête par un sous-agent juge, les gagnants progressant par élimination.
Cas d'utilisation : Optimisation sous critères subjectifs, sélection de style, choix entre des implémentations concurrentes.
Exemple : Un bracket par paires sur les réécritures d'un gestionnaire createOrder désordonné. Plusieurs rédacteurs produisent chacun des réécritures candidates avec des priorités différentes, puis un juge les compare en tête-à-tête, faisant progresser les gagnants tour par tour jusqu'à ce qu'un champion se démarque. Il revient avec le raisonnement du juge.
Voir la trace ici.
Boucle jusqu'à épuisement
L'agent exécute une boucle de découverte, en dédupliquant ce qu'il a déjà trouvé, jusqu'à ce qu'aucun nouveau résultat n'apparaisse. Utile lorsque le périmètre du travail n'est pas connu à l'avance.
Cas d'utilisation : Recherche exhaustive, détection de code mort, audits de dépendances, toute exploration où vous voulez l'exhaustivité plutôt qu'un nombre fixe de résultats.
Exemple : Un balayage de sécurité par passes. L'agent exécute une passe d'analyse, inspecte ce qu'il a trouvé dans le code, et ne démarre une autre passe que si la précédente a révélé de nouveaux problèmes. Il s'arrête lorsqu'une passe ne donne rien de nouveau. Il rapporte les résultats consolidés et le nombre de passes nécessaires.
Voir la trace ici.
Conclusion
Les sous-agents dynamiques sont la façon de donner aux agents plus d'autonomie et une fiabilité accrue. Le code gère la couverture et le contexte intermédiaire, et le modèle effectue toujours le travail nécessitant du jugement. Les schémas ci-dessus sont un point de départ. En pratique, les agents les composent et les mélangent en fonction de ce que la tâche exige.
C'est l'idée du Recursive Language Model dans sa forme la plus simple. Un agent qui écrit du code, et ce code répartit davantage d'agents. C'est un agent qui s'appelle lui-même de manière récursive et qui n'est pas limité par une fenêtre de contexte ou enfermé dans un workflow fixe. Un agent peut décomposer le problème aussi loin qu'il va et réassembler les pièces dans la forme qui convient. Les schémas d'orchestration mis en évidence ci-dessus sont des aperçus précoces de ce qui est possible, mais le plafond ne fera que continuer à s'élever à mesure que les modèles deviendront meilleurs pour écrire du code.
Les sous-agents dynamiques sont la façon dont Deep Agents met cela entre vos mains dès aujourd'hui. Commencez par ajouter un interpréteur de code à votre agent, ou utilisez dcode où les sous-agents dynamiques fonctionnent immédiatement.
Remerciements
Co-écrit par @colifran_ et @huntlovell. Remerciements à @hwchase17, @masondrxy, et @chester_curme pour leur relecture attentive.
