Claude Code Workflows Dynamiques : Exécution de Centaines de Sous-Agents Parallèles avec Opus 4.8

Claude Opus 4.8 a été livré avec une fonctionnalité phare pour Claude Code : les Flux de travail dynamiques. En une seule session, un agent d'orchestration peut lancer des centaines de sous-agents parallèles pour s'attaquer à une tâche vaste et ramifiée : refactoriser des dizaines de fichiers, exécuter une large matrice de tests, ou explorer plusieurs pistes de solution à la fois. Cela semble magique dans le terminal. En coulisses, ce sont deux éléments concrets qui fonctionnent ensemble.

Ce guide explique comment fonctionnent réellement les Flux de travail dynamiques, quand les utiliser, et comment construire le même modèle d'orchestration via l'API brute. Pour en savoir plus sur le modèle lui-même, consultez qu'est-ce que Claude Opus 4.8. Pour le contexte de l'architecture d'agent, notre analyse de l'architecture du harnais d'agent Claude Code est la lecture complémentaire.

Ce que sont réellement les Flux de travail dynamiques

Dans Claude Code, les Flux de travail dynamiques apparaissent comme un mode appelé ultracode dans le menu d'effort. Voici la partie à comprendre : ultracode n'est pas un nouveau niveau d'effort d'API. C'est une combinaison de deux choses qui existent déjà dans Opus 4.8 :

1. Le niveau d'effort xhigh
2. Les messages système en cours de conversation

Combinés, ces éléments donnent à un agent orchestrateur à la fois la profondeur de raisonnement pour planifier une tâche importante et l'autorisation permanente de lancer des agents de travail au fur et à mesure que la tâche se déroule. C'est toute l'astuce. Tout le reste est de l'implémentation spécifique à Claude Code.

Ingrédient 1 : l'effort xhigh

Le paramètre effort contrôle le nombre de tokens qu'Opus 4.8 dépense pour une réponse, y compris les appels d'outils. xhigh est le niveau qu'Anthropic recommande pour le codage à long terme et le travail agentique ; il est optimisé pour des exécutions qui dépassent 30 minutes avec des budgets de tokens de plusieurs millions.

Pour un Flux de travail dynamique, cette profondeur est importante car l'orchestrateur doit faire une véritable planification : décomposer la tâche en unités indépendantes, décider du nombre d'agents de travail à générer et fusionner leurs résultats. Des niveaux d'effort inférieurs réduisent la portée du travail et effectuent moins d'appels d'outils, ce qui est l'inverse de ce dont un orchestrateur a besoin. Lorsque vous exécutez xhigh, définissez un grand `max_tokens` (64K est un bon point de départ) afin que le modèle ait de la marge pour réfléchir et coordonner.

Ingrédient 2 : les messages système en cours de conversation

C'est la nouvelle capacité de l'API Messages qui rend le tout possible. Avant Opus 4.8, une invite système se trouvait au début d'une conversation et restait fixe. Maintenant, vous pouvez placer une entrée système à mi-chemin dans le tableau `messages`, injectant de nouvelles instructions ou permissions en cours de tâche.

C'est ce qui accorde à un orchestrateur l'autorisation permanente de lancer des flux de travail multi-agents après le début de la conversation, plutôt que de la négocier à l'avance. Anthropic documente ce mécanisme dans les messages système en cours de conversation. C'est un petit changement d'API avec une grande conséquence : les agents peuvent désormais acquérir des capacités au milieu d'une exécution en fonction de ce qu'ils découvrent.

Activer les Flux de travail dynamiques dans Claude Code

Dans Claude Code, les Flux de travail dynamiques se trouvent derrière l'option ultracode dans le menu d'effort. La sélection de cette option définit l'effort xhigh et accorde à la session l'autorisation de générer des sous-agents parallèles via des messages système en cours de conversation. À partir de là, vous décrivez une tâche importante et laissez l'orchestrateur la répartir.

Quelques éléments se produisent automatiquement :

• Claude planifie la tâche et décide comment la diviser
• Il lance des agents de travail en parallèle, chacun étant limité à une partie du travail
• Les résultats sont renvoyés en flux et fusionnés dans la session principale

Si vous avez configuré Claude Code avec un plan, notre guide de configuration du SDK d'agent Claude avec plan Claude couvre la configuration environnante.

Quand utiliser les Flux de travail dynamiques (et quand ne pas les utiliser)

Les Flux de travail dynamiques excellent dans les tâches étendues et parallélisables :

• Refactoriser un motif sur de nombreux fichiers à la fois
• Générer et exécuter une large matrice de tests
• Explorer plusieurs approches d'implémentation en parallèle, puis les comparer
• Analyse de base de code à grande échelle où chaque agent de travail prend en charge un module

Ils ne sont pas l'outil approprié pour les tâches étroites et séquentielles. Générer des centaines de sous-agents pour une modification d'un seul fichier brûle des tokens sans avantage, et les agents de travail parallèles ne peuvent pas aider lorsque chaque étape dépend de la précédente. Le coût est réel : des centaines de sous-agents xhigh signifient des millions de tokens. Adaptez le modèle à la forme du travail.

Construire la même chose via l'API

Vous n'avez pas besoin de Claude Code pour construire l'orchestration. Les deux mêmes ingrédients sont disponibles sur l'API Messages brute, et Anthropic fournit un exemple fonctionnel dans construire un mode d'orchestration. La structure est la suivante :

1. Exécuter un appel d'orchestrateur avec un effort xhigh qui planifie la tâche
2. Utiliser des messages système en cours de conversation pour accorder à l'orchestrateur l'autorisation de distribuer des agents de travail
3. Distribuer les appels d'agents de travail en parallèle, chacun étant limité à une unité de travail
4. Collecter les résultats et les renvoyer à l'orchestrateur pour fusion

import anthropic

client = anthropic.Anthropic()

orchestrator = client.messages.create(
    model="claude-opus-4-8",
    max_tokens=64000,
    output_config={"effort": "xhigh"},
    thinking={"type": "adaptive"},
    messages=[
        {"role": "user", "content": "Plan a refactor of the auth module across all 14 services."},
    ],
)

Chaque agent de travail est un appel Messages distinct que vous pouvez exécuter simultanément, souvent à un niveau d'effort inférieur puisque sa tâche est étroite. Si vous pesez le pour et le contre par rapport à l'infrastructure d'agents hébergée d'Anthropic, le guide agents gérés vs SDK d'agent expose les compromis.

Coût et contrôle

Les sous-agents parallèles multiplient rapidement la dépense de tokens. Un Flux de travail dynamique qui lance 200 agents de travail, chacun dépensant des dizaines de milliers de tokens en xhigh, représente un coût réel. Trois habitudes permettent de maîtriser cela :

• Délimitez précisément la portée des agents de travail et exécutez-les avec un effort medium ou low lorsque la sous-tâche le permet
• Plafonnez les `max_tokens` par agent de travail afin qu'un agent incontrôlable ne puisse pas épuiser votre budget
• Mettez en cache le contexte partagé afin que l'invite système répétée ne soit pas facturée au tarif plein pour chaque agent de travail

La ventilation des prix d'Opus 4.8 contient les calculs sur les niveaux d'effort et la mise en cache. En bref : l'orchestration est puissante, mais la facture évolue avec le nombre d'agents, alors traitez le parallélisme comme un choix délibéré.

Tester votre orchestration avec Apidog

Lorsque vous construisez une orchestration via l'API, la partie difficile à déboguer est la distribution (fan-out) : les agents de travail reçoivent-ils le bon contexte délimité, leurs réponses ont-elles la forme attendue par votre étape de fusion, et votre message système en cours de conversation arrive-t-il correctement ? Vous ne voulez pas découvrir un bug après 200 appels d'agents de travail réels.

Apidog vous permet de tester les éléments de manière isolée :

• Enregistrez la requête de l'orchestrateur et inspectez la décomposition des tâches planifiées avant de distribuer quoi que ce soit
• Simulez le point d'accès de l'agent de travail afin de pouvoir tester votre logique de distribution et de fusion sans dépenser de tokens pour des centaines d'appels réels
• Ajoutez des assertions sur la forme de la réponse de l'agent de travail afin qu'une charge utile déviante échoue bruyamment
• Rejouez un seul appel d'agent de travail à différents niveaux d'effort pour ajuster le coût par agent de travail

Téléchargez Apidog, créez les requêtes de l'orchestrateur et des agents de travail vers `https://api.anthropic.com/v1/messages`, et validez d'abord la boucle sur des simulations. Le guide de l'API Opus 4.8 contient la requête de base pour commencer. Une fois que la logique est solide sur les simulations, passez au point d'accès réel.

FAQ

Que sont les Flux de travail dynamiques dans Claude Code ? Une fonctionnalité qui permet à une session de lancer des centaines de sous-agents parallèles pour gérer des tâches vastes et ramifiées. Elle est alimentée par l'effort xhigh et les messages système en cours de conversation sur Opus 4.8.

Ultrasound est-il un niveau d'effort distinct ? Non. Ultracode est le nom de Claude Code pour l'effort xhigh associé à une autorisation permanente de lancer des flux de travail multi-agents. Les niveaux d'effort de l'API sont toujours low, medium, high, xhigh et max.

Que sont les messages système en cours de conversation ? Un changement de l'API Messages dans Opus 4.8 qui vous permet de placer une entrée système à mi-chemin dans la conversation, injectant de nouvelles instructions ou permissions en cours de tâche. C'est ce qui permet à un orchestrateur de générer des agents de travail après le début d'une exécution.

Puis-je construire des Flux de travail dynamiques sans Claude Code ? Oui. Utilisez l'effort xhigh et les messages système en cours de conversation sur l'API Messages brute. Anthropic publie un exemple d'orchestration fonctionnel dans sa documentation.

Les Flux de travail dynamiques coûtent-ils cher ? Oui, ils peuvent. Des centaines de sous-agents xhigh représentent des millions de tokens. Délimitez précisément la portée des agents de travail, réduisez leur effort lorsque cela est possible, et mettez en cache le contexte partagé pour contrôler les dépenses.

Quand dois-je éviter les Flux de travail dynamiques ? Pour les tâches étroites ou strictement séquentielles. Les agents de travail parallèles n'apportent aucune valeur lorsque chaque étape dépend de la précédente, et ils gaspillent des tokens sur de petites tâches.