Run Antigravity Workflows With Parallel Agents Safely

Un seul agent qui passe à travers cinquante fichiers modifiés dans une seule conversation va perdre le fil. Il lit, il cherche, il lance des tests, et tout ce détail s’entasse dans une seule fenêtre de contexte jusqu’à ce que le travail du début s’efface. Google Antigravity a pris une autre voie le 13 novembre avec Dynamic Workflows, et ce changement vaut la peine d’être compris avant de lui confier du vrai code.

Avec Dynamic Workflows, la coordination sort de la conversation et entre dans le code. Vous tapez /run-workflow et une tâche. L’agent lit sa compétence de flux de travail intégrée et écrit un court script Python pour cette tâche. Antigravity vous montre le script et vous demande de l’approuver. Le script roule ensuite en arrière plan pendant que vous continuez à travailler, et l’agent principal lit les journaux à la fin et résume les résultats.

Ce tutoriel suit la documentation officielle d’Antigravity pour Dynamic Workflows et pour les commandes barre oblique, vérifiée le 14 novembre 2026. Il ne prétend pas avoir fait un essai de son côté. L’ordre de sécurité compte plus que la vitesse. Une tâche de révision vient en premier parce qu’elle ne change rien. La modification vient plus tard, et seulement dans des espaces de travail isolés.

Ce que vous allez construire ou apprendre

Vous allez lancer une révision en parallèle des fichiers Python modifiés depuis main, avec un agent par fichier et un verdict d’une ligne de chaque agent. En chemin, vous allez apprendre à lire un script produit, à choisir un modèle pour chaque agent, et à repérer les réglages qui gardent le travail en parallèle sûr.

Vous allez aussi apprendre quand ne pas utiliser un flux de travail. Si des agents doivent se parler pendant qu’ils travaillent, Antigravity vous dirige vers /swarm, où les agents partagent un tableau de messages. Si la tâche est un seul travail que vous pouvez confier en entier, un seul sous agent demande moins de structure. Un flux de travail gagne sa place quand le même contrôle se répète sur une liste, ou quand des étapes doivent rouler dans un ordre précis.

Un agent par fichier, chacun travaillant en même temps et aucun ne partageant une conversation. Illustration : Dirty Static

Avant de commencer

Chaque agent qu’un flux de travail lance reçoit sa propre conversation. Cet agent ne peut pas voir le script et ne peut pas voir les autres agents. Cette isolation est le principe même du système, et elle a une conséquence simple. Le script doit donner à chaque agent tout le contexte dont il a besoin, la tâche exacte, et la forme du résultat que vous voulez recevoir. Une consigne vague ne produit pas une réponse vague d’un seul agent. Elle produit des réponses vagues de vingt agents à la fois.

Connaissez les cinq blocs de base avant de lire un script. phase(name) commence une phase nommée et regroupe les journaux et les cartes d’agents sous cette phase. log(*args) ajoute une ligne à la phase. agent(prompt, schema, role, type_name, workspace, model) définit un agent. parallel(items, fn) roule une fonction pour chaque élément en même temps et rend les résultats dans l’ordre des éléments, et si un élément échoue, les autres sont annulés. pipeline(items, fn) roule les éléments un à la fois dans l’ordre. await trajectory(...) apporte dans le script des étapes plus anciennes de votre conversation.

Étape 1 : Choisissez une tâche qui se divise bien

Action : choisissez une tâche qui se divise en éléments qui ne dépendent pas les uns des autres, ou en étapes avec un ordre clair. De bonnes premières tâches incluent une révision de chaque fichier modifié, un audit de chaque paquet, ou une boucle de test et de correction pour un bogue à la fois. Écrivez le résultat voulu en une phrase avant de taper la commande.

Résultat attendu : vous pouvez nommer la liste des éléments, le travail fait sur chaque élément, et le résultat que vous voulez pour chacun. Si vous ne pouvez pas nommer ces trois choses, la tâche n’est pas encore prête pour un flux de travail.

Étape 2 : Écrivez la consigne avec les contrôles nommés

Action : dans une conversation dans l’App ou le CLI, tapez /run-workflow puis la tâche. Nommez le niveau de modèle, la forme du résultat, et l’espace de travail dans la consigne quand ces choix comptent. Pour la première tâche, utilisez cette consigne telle quelle, en ajustant seulement le nom de la branche si votre branche principale porte un autre nom.

/run-workflow List the Python files changed since main, then review each file in parallel for unhandled exceptions using the flash model, and log a one-line verdict per file.

Résultat attendu : l’agent écrit un script Python pour la tâche et vous le montre dans une demande qui pose, dans les mots des documents, la question Allow running this workflow script? Rien ne roule encore. Si votre préréglage de permissions autorise déjà les scripts, comme le préréglage Turbo nommé dans les documents, le script peut rouler sans cette demande, ce qui est une raison de plus de régler votre préréglage avec soin avant de commencer.

Étape 3 : Lisez le script produit ligne par ligne

Action : lisez le script avant de l’approuver, et vérifiez cinq choses dans l’ordre. Les phases correspondent aux étapes que vous avez demandées. Chaque appel agent() donne à l’agent son contexte complet et sa tâche dans le texte de la consigne. Chaque schema correspond au résultat que vous voulez, comme un tableau de chaînes pour une liste de chemins ou une simple chaîne pour un verdict. Le modèle nommé pour chaque agent convient au travail, avec flash_lite ou flash pour des contrôles rapides sur beaucoup de fichiers et pro pour un travail qui demande un raisonnement plus poussé, selon les documents. Le réglage d’espace de travail convient au risque, ce qui pour une tâche de révision veut dire le réglage par défaut qui utilise votre espace actuel et n’écrit rien.

Le script pour la consigne de l’étape 2 devrait ressembler à cet exemple tiré de la documentation officielle. Le code dans un script de flux de travail est une donnée tirée des documents, montrée ici pour que vous puissiez la comparer avec ce que votre agent produit.

phase("Discover")

files = await agent(
    "List the Python files changed since main. Paths only.",
    schema={"type": "array", "items": {"type": "string"}},
)

phase("Review")

# parallel() runs one agent per file at the same time.
# role titles each agent's card.

reviews = await parallel(
    files,
    lambda f: agent(
        f"Review {f} for unhandled exceptions. Reply with a one-line verdict.",
        schema={"type": "string"},
        role=f"Review {f}",
        model="flash",
    ),
)

for r in reviews:
    log(r)

Résultat attendu : chaque ligne fait ce que vous attendez, et rien dans le script ne dépasse la tâche. Si une ligne vous surprend, choisissez No à la demande d’approbation et dites à l’agent ce qu’il faut changer. Les documents donnent exactement ce chemin. Refusez, décrivez le changement, et relisez le nouveau script.

Étape 4 : Approuvez le script et suivez les phases

Action : à la demande d’approbation, choisissez l’option qui autorise le script cette fois seulement. Pendant que le flux de travail roule, ouvrez l’étape du flux de travail dans votre conversation. Vous devriez voir une section par phase, les lignes de journal pour cette phase, et une carte par agent avec son rôle et son état, comme en cours, en attente de votre approbation, ou terminé. Cliquez sur une carte d’agent pour ouvrir la conversation de cet agent dans le panneau latéral, où vous pouvez lire sa consigne, suivre ses appels d’outils, approuver une demande en attente, ou lui envoyer un message.

Résultat attendu : le titre de l’étape montre la phase actuelle et combien d’agents ont terminé, dans la forme que les documents donnent comme flux de travail, le nom de la phase, et un compte comme 3 agents sur 4. La conversation montre qu’une tâche roule, et le flux de travail apparaît sous Background Tasks dans la vue Overview du panneau latéral. Pour arrêter un flux de travail tôt, arrêtez la conversation parente. Les documents disent qu’arrêter la conversation parente arrête aussi chaque agent de flux de travail en cours.

Étape 5 : Lisez les résultats face au schéma

Action : quand le script se termine, lisez le résumé que l’agent principal vous donne, puis lisez les verdicts consignés eux mêmes. Chaque agent a envoyé son résultat par un outil nommé finish, et cet outil vérifie le résultat face au schéma dans le script avant que le script reçoive la valeur analysée. Les lectures de fichiers, les recherches, et la sortie des tests restent dans les conversations des agents, donc votre conversation principale reste claire même sur une grosse tâche.

Résultat attendu : vous tenez un verdict par fichier modifié, dans l’ordre des fichiers, parce que parallel() rend les résultats dans l’ordre des éléments. Un fichier avec un verdict propre ne demande aucune action. Un fichier avec un verdict de problème a maintenant un souci nommé sur lequel vous pouvez agir à l’étape 6 ou dans une conversation normale. Si un agent a échoué, attendez vous à ce que le reste de cet appel en parallèle ait été annulé, selon les documents, et relancez le flux de travail pour les fichiers manquants plutôt que de deviner leurs verdicts.

Étape 6 : Laissez les agents modifier seulement dans des espaces de branche

Action : seulement après qu’une tâche de révision a roulé sans souci, passez à la modification. Dans votre consigne, demandez un espace de travail de branche pour chaque agent en parallèle. Les documents nomment ce réglage workspace="branch", et il donne à chaque agent son propre arbre de travail Git isolé, donc les agents peuvent changer des fichiers et lancer des tests en même temps sans écraser le travail des autres. Une consigne dans le style de l’exemple des documents se lit comme suit.

/run-workflow For each package under packages/, start one agent in an isolated branch workspace to replace the deprecated request() helper with fetchJson(), run npm test in that package, and log a diff summary and the test result.

Résultat attendu : chaque agent travaille dans son propre arbre de travail, lance les tests de son propre paquet, et consigne un résumé des différences plus un résultat de test. Révisez chaque différence vous même avant que ce travail rejoigne votre branche. Un espace de travail de branche isole les fichiers. Il ne juge pas si un changement est bon, et ce jugement reste le vôtre. Notre guide sur les sessions d’agents en bac à sable couvre le modèle plus large qui donne aux agents un endroit borné où travailler.

Étape 7 : Gardez un script qui fonctionne et relancez le

Action : quand un flux de travail fait bien une tâche, demandez à l’agent de garder le script dans un fichier .py dans votre espace de travail. Plus tard, relancez le avec une consigne qui nomme le fichier, dans la forme que les documents donnent.

/run-workflow Run scripts/review-changes.py

Résultat attendu : Antigravity vous demande d’approuver le script chaque fois qu’il roule, sauf si vous avez choisi de toujours l’autoriser. Gardez les scripts conservés sous révision avec le reste de votre code. Un script conservé qu’une équipe peut lire et relancer est le vrai gain ici. Le même audit roule de la même façon le mois prochain, et un nouveau membre de l’équipe peut lire le script pour apprendre comment l’audit fonctionne. Le flux de travail roule dans un processus distinct avec l’environnement Python qui vient avec Antigravity, donc aucune installation locale de Python n’est requise, et vous pouvez régler la variable d’environnement ANTIGRAVITY_PYTHON si vous avez besoin d’un autre interpréteur.

Vérification

Faites ces contrôles après votre premier flux de travail et notez les résultats. La demande d’approbation a montré le script complet avant que quoi que ce soit roule, ou votre préréglage de permissions est un choix que vous avez fait exprès. L’étape du flux de travail a montré des phases nommées, et le compte d’agents a atteint le compte complet pour la tâche. Les résultats sont revenus dans l’ordre des éléments et chaque résultat respectait le schéma que vous avez réglé. Aucun fichier dans votre espace de travail n’a changé pendant la tâche de révision, ce que vous pouvez confirmer avec git status dans votre dépôt.

Terminez par le contrôle des crédits. Comptez les agents que le flux de travail a lancés et notez le modèle que chacun a utilisé. Ce compte, fois les appels que chaque agent a faits, est ce que la tâche a coûté en crédits de forfait. Si le compte est plus grand que la liste de fichiers que vous attendiez, votre phase de découverte a trouvé plus d’éléments que vous pensiez, et les journaux du script montreront la liste sur laquelle il a travaillé.

Dépannage

Prochaines étapes

Prenez une tâche qui revient dans votre propre travail et donnez lui la forme d’un flux de travail. Une révision hebdomadaire des fichiers modifiés est un bon départ, et un audit de chaque paquet avant une sortie en est un autre. Gardez le script, gardez les premiers passages en lecture seule dans les faits, et élargissez ce que les agents peuvent faire seulement après que les résultats ont gagné votre confiance sur plusieurs passages.

Si votre prochaine tâche demande que des agents débattent d’une interface ou vérifient le travail des autres à mesure qu’il arrive, lisez les documents Antigravity sur /swarm avant de forcer cette tâche dans un script de flux de travail. Les scripts servent un contrôle de déroulement que vous pouvez énoncer d’avance. Cette limite n’est pas un défaut de l’outil. C’est la raison pour laquelle on peut faire confiance à l’outil pour du travail en parallèle.

Sources

• Documentation Google Antigravity, Dynamic Workflows (/run-workflow), antigravity.google/docs/dynamic-workflows, vérifiée le 14 novembre 2026. La source pour le déroulement du flux de travail, les blocs de base, l’exemple de script, les options de modèle et d’espace de travail, les permissions, et la capture d’écran de la demande d’approbation utilisée dans cet article.
• Documentation Google Antigravity, Slash commands, antigravity.google/docs/slash-commands, vérifiée le 14 novembre 2026. La source pour l’offre Google AI Pro et Ultra pour /run-workflow.
• Journal des changements Google Antigravity, entrée du 13 novembre 2026, antigravity.google/docs/changelog. La source pour la date de sortie de Dynamic Workflows.
• AlphaSignal, Google Antigravity Ships Dynamic Workflows to Run Parallel AI Coding Agents, 13 novembre 2026. Couverture du lancement utilisée pour la note que les flux de travail n’ont pas de prix distinct et utilisent les crédits de modèle du forfait.
• Crédit d’image : la capture d’écran de la demande d’approbation dans cet article vient de la documentation Google Antigravity. Les autres images sont des illustrations Dirty Static.