Exécuter plusieurs agents dans Antigravity : les schémas qui fonctionnent vraiment

Exécuter plusieurs agents dans Antigravity paraît simple, jusqu’à ce que le troisième agent plante en silence et que vous passiez quarante minutes à vous demander pourquoi le résultat est bâclé. L’exécution parallèle est l’une des fonctions les plus puissantes d’Antigravity, mais elle exige un modèle mental précis. Cet article présente ce qui fonctionne réellement en production, la façon dont les équipes structurent leurs pipelines d’agents, et les pièges à éviter, qui paraissent anodins au premier abord.

Ce qu’Antigravity fait différemment

La plupart des frameworks d’agents sérialisent par défaut. Vous définissez une tâche, un agent la prend, la termine, et ce n’est qu’ensuite que la suivante démarre. Antigravity inverse cette logique. Son ordonnanceur central repose sur une boucle événementielle concurrente qui traite les tâches d’agents comme des éléments de premier plan, et non comme des ajouts greffés après coup sur un pool de threads.

La boucle qui fait tout tourner

Au cœur d’Antigravity tourne une boucle réactive. Lorsque vous enregistrez un agent, vous ne lancez pas un nouveau processus. Vous enregistrez une coroutine que l’ordonnanceur gère. Cela signifie que la latence se cumule autrement que dans les systèmes à threads. Dix agents exécutés en parallèle dans Antigravity surpasseront généralement dix appels séquentiels, car le temps d’attente des entrées-sorties, qui représente l’essentiel du temps des appels à un LLM (80 %), est partagé au sein du pool.

L’idée essentielle est la suivante : concurrent ne veut pas dire incontrôlé. Antigravity vous fournit les briques de base, mais la logique de coordination vous revient entièrement.

Pourquoi les limites d’un agent unique comptent

Avant d’ajouter des agents, il est utile de comprendre pourquoi le mode à agent unique existe par défaut. Un agent seul est prévisible. Il lit un contexte, agit dessus et renvoie un résultat. Dès qu’un second agent lit le même contexte, le risque de sorties divergentes apparaît. Antigravity ne les réconcilie pas par magie. C’est à vous de le faire.

💡 Commencez avec un seul agent, repérez où il passe son temps à attendre, et ce n’est qu’ensuite que vous déciderez quelles attentes valent la peine d’être parallélisées.

Configurer plusieurs agents

Configurer plusieurs agents dans Antigravity exige de trancher trois points en amont : comment les agents sont lancés, s’ils partagent un état, et comment ils renvoient leurs résultats à l’orchestrateur.

Lancer des agents en parallèle

L’approche la plus directe consiste à lancer explicitement les agents au niveau de la définition des tâches. Au lieu d’appeler les agents les uns après les autres, vous définissez un lot de tâches et laissez l’ordonnanceur les répartir simultanément.

tasks = [
    agent.create_task("summarize", doc_a),
    agent.create_task("summarize", doc_b),
    agent.create_task("summarize", doc_c),
]
results = await asyncio.gather(*tasks)

Copier le prompt

Le détail critique : asyncio.gather dans Antigravity respecte la taille du pool d’agents. Si vous réglez max_concurrent=3 et envoyez 10 tâches, les trois premières démarrent immédiatement. Les sept restantes sont mises en file d’attente. Il s’agit d’un contrôle de débit voulu, et non d’un bug.

État partagé ou tâches isolées

C’est la décision qui fait échouer la plupart des configurations multi-agents. Il existe trois schémas valides :

Les tâches isolées constituent presque toujours le choix par défaut. Si deux agents ont besoin du même élément de données, transmettez une copie à chacun. Le coût en mémoire en vaut la prévisibilité.

L’état en écriture partagée doit être traité comme un dernier recours, et non comme une commodité. Si vous en avez absolument besoin, utilisez les StateManager intégrés à Antigravity avec un verrouillage explicite, plutôt qu’un simple dictionnaire Python.

Transmettre le contexte entre agents

Lorsque la sortie de l’agent A alimente l’agent B, il existe une dépendance. Dans Antigravity, les dépendances cassent le parallélisme par définition. Deux agents qui dépendent l’un de l’autre ne peuvent pas tourner en même temps.

Le schéma le plus propre est le transfert explicite :

summary = await agent_a.run(document)
analysis = await agent_b.run(summary)

Copier le prompt

Pour les grands pipelines aux dépendances mixtes, utilisez une approche par graphe de dépendances. Définissez quelles tâches sont indépendantes (exécutées en parallèle) et lesquelles sont séquentielles (exécutées dans l’ordre), puis laissez l’ordonnanceur d’Antigravity gérer le reste.

Les schémas qui tiennent à grande échelle

Trois schémas couvrent environ 90 % des cas d’usage multi-agents dans Antigravity. Ils ne sont pas exotiques. Ils sont banals, et c’est tant mieux.

Le schéma en éventail

Le schéma en éventail est le plus courant pour le traitement par lots. Une entrée, de nombreux agents en parallèle, un point de collecte.

Fonctionnement :

1. L’orchestrateur reçoit un lot d’éléments, par exemple 20 documents
2. L’orchestrateur lance un agent par élément (ou par fragment)
3. Tous les agents tournent en simultané
4. L’orchestrateur collecte tous les résultats une fois qu’ils sont terminés

Ce schéma brille lorsque les tâches sont parfaitement parallélisables : aucun agent n’a besoin de savoir ce que font les autres. La génération d’images, la synthèse de documents, les tâches de classification et la traduction entrent parfaitement dans ce cadre.

💡 Pour de très gros lots, ajoutez un sémaphore pour contrôler la concurrence maximale : asyncio.Semaphore(10) garantit que vous ne lancez jamais plus de 10 agents à la fois, ce qui protège les limites de débit des API en aval.

La chaîne de pipeline

La chaîne de pipeline est le pendant du schéma en éventail : un flux strictement séquentiel où chaque agent s’appuie sur la sortie du précédent.

Agent 1 (Research) → Agent 2 (Draft) → Agent 3 (Edit) → Agent 4 (Format)

Copier le prompt

Idéal pour : les tâches dont la qualité dépend d’un affinage progressif. La rédaction, la génération de code et le raisonnement en plusieurs étapes profitent des chaînes de pipeline, car les agents suivants peuvent corriger les erreurs des agents précédents.

Le risque des chaînes de pipeline est la propagation d’erreurs. Si l’agent 1 renvoie une sortie erronée, les agents 2 à 4 vont construire avec assurance sur cette erreur. Ajoutez une validation entre les étapes, même si ce n’est qu’un simple contrôle de longueur ou de schéma.

Le modèle superviseur

Le modèle superviseur est le plus sophistiqué des trois. Un agent, le superviseur, orchestre un pool d’agents ouvriers. Le superviseur ne fait pas le travail lui-même. Il planifie, délègue, relit et décide s’il faut relancer une tâche.

Les responsabilités du superviseur :

• Décomposer la tâche initiale en sous-tâches
• Assigner les sous-tâches aux agents ouvriers appropriés
• Valider chaque résultat avant de le transmettre en aval
• Gérer les échecs en relançant, en réassignant ou en faisant remonter le problème

Pour ce schéma, Kimi K2.6 et GPT 5.1 sont d’excellents modèles superviseurs. Tous deux sont conçus pour l’orchestration d’agents, GPT 5.1 étant spécialement pensé pour la création d’agents d’IA. Comme ouvriers, des modèles plus légers comme Claude 4.5 Haiku ou GPT 4.1 Mini réduisent nettement les coûts sans sacrifier la qualité sur des tâches bien délimitées.

Là où les choses cassent

La plupart des échecs multi-agents dans Antigravity relèvent de deux catégories. Les deux sont évitables une fois qu’on sait quoi surveiller.

Conditions de concurrence sur les ressources partagées

Une condition de concurrence se produit lorsque deux agents écrivent sur la même ressource au même moment, sans que l’un sache que l’autre existe. Dans Antigravity, cela se manifeste généralement ainsi :

• Deux agents mettent à jour le même fichier : la seconde écriture écrase la première en silence
• Deux agents appellent le même point de terminaison d’API : les limites de débit se déclenchent sans prévenir
• Deux agents mettent à jour un dictionnaire partagé : une mise à jour disparaît

La solution consiste à ne jamais écrire sur une ressource partagée sans verrou. Concrètement, cela donne :

lock = asyncio.Lock()

async def safe_write(lock, data, destination):
    async with lock:
        destination.append(data)

Copier le prompt

Pour les ressources externes comme les fichiers ou les API, sérialisez les écritures via un seul agent d’écriture dédié. Les autres agents transmettent leurs sorties à cet agent ; c’est le seul à toucher la ressource.

Collisions de budget de tokens

Celui-ci est moins évident. Lorsque vous exécutez plusieurs agents simultanément, chaque agent demande des tokens au même point de terminaison de modèle. Si vous ne gérez pas votre consommation totale de tokens en simultané, vous atteindrez les limites de débit à des moments imprévisibles.

Le schéma à adopter ici est une gestion du budget de tokens au niveau de l’orchestrateur. Avant de lancer des agents, estimez le total de tokens nécessaires pour le lot. Si l’estimation dépasse la fenêtre de limite de débit, introduisez un délai ou réduisez la taille du lot.

💡 Pour les charges parallèles lourdes, Llama 4 Maverick Instruct et Deepseek v3.1 offrent des options à haut débit avec des limites généreuses, ce qui en fait des choix pratiques pour les pipelines d’agents à gros volume.

Symptômes courants d’une collision de budget de tokens :

• Les agents terminent, mais certains résultats sont tronqués
• Erreurs 429 intermittentes, sans schéma clair
• La qualité globale baisse à mesure que la taille du lot augmente
• Certains agents renvoient des réponses vides ou partielles

Si vous constatez l’un de ces symptômes, vérifiez votre consommation de tokens en simultané avant de supposer un bug dans la logique de vos agents.

Associer les agents à la génération d’images par IA

Les configurations multi-agents deviennent particulièrement intéressantes lorsque vous combinez des tâches de génération de texte et d’images. Un cas d’usage réel courant : générer un lot d’articles, puis produire automatiquement des images pour chacun d’eux en parallèle.

Un agent par type de média

L’approche la plus propre attribue des agents distincts à des types de médias distincts. Un agent gère toute la génération de texte. Un pool d’agents séparé traite toutes les demandes de génération d’images. Les deux pools tournent en simultané sans jamais interagir directement.

Structure type :

1. Le pool d’agents texte traite les articles en parallèle
2. Chaque article terminé est transmis à la file d’images
3. Les agents image récupèrent les tâches de la file et génèrent les visuels
4. Un agent collecteur regroupe les paires texte et image pour le résultat final

Cette séparation compte pour une raison pratique. La génération de texte et la génération d’images ont des profils de latence très différents. Un texte de 1 000 mots peut prendre 8 secondes. La génération d’une image peut en prendre de 15 à 25. Si vous les mélangez dans le même pool d’agents, les tâches textuelles rapides feront la queue derrière les tâches d’image lentes. Les séparer maximise le débit des deux.

Utiliser des LLM comme coordinateurs sur PicassoIA

Pour les flux de travail qui combinent rédaction et production visuelle, utiliser un LLM comme coordinateur et des modèles d’image dédiés comme ouvriers constitue une architecture très efficace. Le LLM gère la décomposition des tâches, l’affinage des prompts et la relecture de qualité. Les modèles d’image assurent la génération proprement dite.

Sur PicassoIA, cela correspond à une répartition naturelle :

• Coordinateur : Claude Opus 4.7 ou GPT 5 pour l’orchestration, la planification et la relecture
• Ouvriers image : des modèles texte vers image pour la génération d’images en parallèle
• Contrôle qualité : Kimi K2 Instruct ou Gemini 3 Pro pour valider les sorties selon des critères définis

💡 Lorsque vous construisez des pipelines d’agents multimodaux, traitez l’ingénierie des prompts comme une tâche de premier plan. Confiez à un agent LLM dédié le seul affinage des prompts d’image à partir du contenu brut de l’article, avant de les transmettre aux modèles d’image. La qualité des résultats s’améliore nettement grâce à cette étape.

Bien gérer l’état des agents

L’état est le tueur silencieux des systèmes multi-agents. Les agents qui portent trop d’état deviennent imprévisibles. Ceux qui n’en portent aucun deviennent inutiles. Le juste milieu est constitué par des agents sans état, avec injection explicite du contexte.

Concrètement, cela signifie :

• Chaque agent reçoit tout ce dont il a besoin dans un seul objet d’entrée
• Les agents ne conservent aucune mémoire interne entre les appels
• Tout l’état réside dans l’orchestrateur, et non dans les agents individuels

Ce modèle, parfois appelé style de passage de messages, rend les agents bien plus faciles à tester, à déboguer et à faire évoluer. Vous pouvez remplacer n’importe quel agent sans mettre à jour les autres, car aucun agent ne détient un état dont les autres dépendent.

Anti-patterns à éviter :

Dès que vous vous surprenez à chercher pourquoi la sortie d’un agent a changé sans que son code ait été modifié, la dérive d’état est presque toujours coupable.

Logique de reprise et tolérance aux pannes

Les systèmes multi-agents en production tombent en panne. Les appels réseau expirent, les API de modèles renvoient des erreurs et, parfois, un agent produit une sortie qui échoue à vos règles de validation. Intégrer la logique de reprise dès le premier jour dans l’orchestrateur, plutôt que de l’ajouter plus tard, fait la différence entre un pipeline fiable et un pipeline fragile.

Une stratégie de reprise concrète :

1. Classer les échecs : transitoires (reprise immédiate), limite de débit (attendre puis reprendre) ou fatals (faire remonter à un humain)
2. Fixer un nombre maximal de reprises par tâche : 3 est une valeur par défaut raisonnable pour la plupart des charges
3. Mettre en place un backoff exponentiel : attendre 1 s, puis 2 s, puis 4 s entre les reprises
4. Journaliser chaque échec avec son contexte : incluez l’ID de la tâche, l’ID de l’agent, le type d’erreur et le hachage de l’entrée

Pour les tâches gourmandes en raisonnement où un agent produit une réponse logiquement fausse plutôt qu’une erreur technique, Deepseek R1 mérite d’être utilisé comme validateur de secours. Son raisonnement étape par étape le rend bien adapté à la détection d’erreurs logiques que d’autres modèles laissent passer.

Reprise ou repli :

Tous les échecs ne justifient pas une reprise avec le même modèle. Envisagez un pool de repli dans lequel les tâches échouées sont réassignées à un autre modèle. Une tâche qui expire sur GPT 5 Pro peut aboutir avec succès sur Claude 4.5 Sonnet, surtout si le délai d’attente vient de la profondeur du raisonnement et non d’un problème de connexion.

Construisez votre premier flux multi-agents

Exécuter plusieurs agents dans Antigravity ne consiste pas à ajouter des modèles à un script. Il s’agit de penser en pipelines, où chaque étape a une entrée claire, une sortie claire et un mode de défaillance clairement identifié.

Les équipes qui tirent le meilleur parti des configurations multi-agents dans Antigravity suivent une progression simple :

1. Faire fonctionner parfaitement un seul agent sur une seule tâche
2. Identifier le goulot d’étranglement (presque toujours l’attente d’entrées-sorties)
3. Paralléliser exactement les tâches qui attendent
4. Ajouter un superviseur si la complexité de coordination augmente
5. Surveiller, relancer et valider à chaque étape

La collection de grands modèles de langage de PicassoIA vous donne toute la gamme de modèles nécessaire à chaque rôle de cette architecture : ouvriers rapides, superviseurs capables et raisonneurs approfondis. Que vous construisiez un pipeline de production de contenu, un outil de recherche automatisé ou un flux de création multimodal, toutes les briques sont disponibles.

Essayez dès aujourd’hui de composer votre premier pipeline en éventail sur PicassoIA. Choisissez une tâche par lots que vous traitez actuellement à la main, confiez-la à trois agents en parallèle avec Kimi K2.6 ou GPT 5.1, et mesurez la différence. Le premier résultat change généralement la façon dont vous envisagez l’automatisation pour de bon.