Google Antigravity lance /swarm : la programmation IA passe de l’exécution par un seul Agent à la collaboration en équipe multi-Agents, analyse de 4 types de rôles

Note de l’auteur : cet article s’appuie sur le blog officiel et la documentation d’utilisation de Google Antigravity. Il explique comment /swarm répartit le travail entre plusieurs agents, comment ils collaborent, comment on visualise et pilote tout cela, et quelles sont les limites d’usage.

Le 10 novembre 2026, Gemini 4 Carbon est devenu officiellement accessible. Le même jour, l’équipe Google Antigravity a lancé la fonctionnalité de collaboration multi-agents /swarm (Preview). Cette commande transforme une simple conversation en une petite équipe d’ingénierie IA : l’un découpe les tâches, un autre écrit le code, un troisième fait les vérifications, et un dernier repère quand la progression se bloque.

Cette fonctionnalité repose sur des sources publiques. Le blog officiel d’Antigravity et la documentation d’utilisation de Swarm sont déjà en ligne, et Google indique que ses ingénieurs l’utilisent en interne depuis environ 5 semaines. L’objectif de /swarm n’est pas d’ouvrir plusieurs fenêtres de chat en parallèle : il cherche à construire un système de collaboration capable de décomposer les tâches de façon autonome, de les exécuter en parallèle, de partager l’avancement, de se vérifier mutuellement et de corriger en continu.

Valeur essentielle : en lisant cet article, vous comprendrez le mécanisme d’exécution concret de /swarm, la façon dont les différents rôles coopèrent, comment l’utilisateur peut observer et intervenir, ainsi que les limites réelles en matière de quotas et de permissions.

Termes clés de Google Antigravity /swarm à connaître

/swarm introduit plusieurs noms de rôles. Autant aligner d’abord ces concepts : la suite sur les mécanismes n’en sera que plus facile à comprendre.

Qu’est-ce que Google Antigravity /swarm : l’essentiel en bref

/swarm a été publié en même temps que l’ouverture officielle de Gemini 4 Carbon, mais ce sont deux choses différentes. Le premier est une fonctionnalité d’orchestration multi-agents dans Antigravity, le second est un modèle. Le tableau ci-dessous récapitule les informations officiellement rendues publiques à ce jour.

Pourquoi un agent seul peine à gérer de grosses tâches d’ingénierie

Un agent seul se débrouille très bien quand il s’agit de traiter une fonction ou un bug. Mais dès que la tâche s’étend à plusieurs dizaines de fichiers, à des dépendances entre plusieurs modules, ou qu’il faut relancer les tests à répétition, il doit garder tous les détails en tête dans un même contexte. Plus ce contexte s’allonge, plus les contraintes posées au début risquent d’être noyées sous les détails d’exécution qui s’accumulent ensuite.

La répartition des tâches est un autre point délicat. Un agent seul ne peut travailler que de manière séquentielle : tant que la modification du module A n’est pas terminée, l’investigation du module B doit attendre. Or beaucoup de tâches d’ingénierie peuvent se découper et se mener en parallèle, par exemple corriger séparément les tests en échec de différents paquets. Les traiter en série, c’est perdre du temps.

Enfin, le point le plus souvent négligé : la vérification. Quand l’agent qui écrit le code relit son propre travail, il reste facilement sur ses hypothèses de départ et ne repère pas les erreurs de raisonnement. Dans une équipe humaine, on demande à quelqu’un d’autre de faire la revue de code. /swarm transpose cette répartition des rôles dans le processus de programmation assistée par IA.

Comment Google Antigravity /swarm démarre une équipe d’agents

D’après la documentation officielle, une fois /swarm <task> lancé, le travail avance dans l’ordre suivant :

1. La conversation en cours devient le Coordinator : l’agent avec lequel vous discutez devient le coordinateur, chargé de comprendre la tâche globale.
2. Découpage du travail : le Coordinator divise la tâche en plusieurs sous-tâches selon sa structure.
3. Création de Workers indépendants : à chaque sous-tâche correspond un Worker, qui reçoit son propre contexte et une description de tâche publique.
4. Exécution et vérification : les Workers modifient le code ou mènent des investigations ; le Verifier contrôle les modifications, lance les tests et renvoie les problèmes au Worker concerné.
5. Boucle de correction : le Worker corrige à partir du retour, puis ses changements sont de nouveau vérifiés.
6. Rapport de synthèse : le Coordinator consolide les résultats de chaque membre et les présente à l’utilisateur.

Le contexte de chaque Worker est isolé : il ne contient que les informations de sa propre partie de la tâche, ce qui réduit le problème de pollution mutuelle des contextes longs. La description des tâches étant publique, chaque membre peut savoir qui travaille sur quoi, et les responsabilités sont clairement délimitées.

/swarm : répartition des rôles entre Coordinator, Worker, Verifier et Monitor

Dans la documentation officielle, une équipe Swarm comprend généralement quatre types de rôles. Précision importante : il s’agit de l’organisation type décrite officiellement, et non d’une architecture fixe appliquée à toutes les tâches. Le nombre de Workers à créer et le besoin de membres supplémentaires sont décidés par le Coordinator en fonction de la tâche.

Les mécanismes du Verifier et du Monitor dans /swarm

Le blog officiel présente le Verifier comme un « agent de vérification adversarial ». Sa mission est de débusquer les problèmes : il examine les modifications des autres agents, exécute les tests et remet en question les changements discutables. Une fois le retour reçu, le Worker corrige puis soumet à nouveau son travail pour contrôle. L’exécution et la vérification forment ainsi une boucle fermée.

Le Monitor, lui, traite un autre type de risque. Quand plusieurs agents collaborent, il peut arriver que tout le monde attende et que personne ne fasse avancer les choses. Le Monitor reste en veille la plupart du temps ; dès qu’il constate que l’équipe est à l’arrêt alors que la tâche n’est pas finie, il réveille les membres concernés. Grâce à lui, quand l’équipe se retrouve bloquée, on n’est pas obligé de compter uniquement sur une intervention manuelle de l’utilisateur.

Dans /swarm, chaque rôle peut utiliser un modèle différent

Dans son blog officiel, Google recommande d’attribuer les modèles selon les caractéristiques de chaque rôle, plutôt que de confier le modèle le plus coûteux à tous les agents :

• Gemini 4 Carbon : conception de l’architecture globale, coordination des tâches, revue de sécurité, audit de code complexe
• Un modèle plus rapide et plus léger : implémentation de code courante, modifications de fichiers en parallèle
• Un agent de vérification dédié : tests et validation automatisés

Dans les exemples de la documentation officielle, on trouve aussi des configurations où des modèles différents se chargent respectivement de l’implémentation du code et de la vérification indépendante. C’est une logique d’équilibre entre coût et capacités : les jugements complexes vont au modèle puissant, et le gros du travail d’exécution au modèle rapide.

💡 Conseil : si vous souhaitez aussi associer des modèles à chaque rôle dans votre propre pipeline multi-agents, vous pouvez commencer par tester, via APIYI (apiyi.com) et avec une seule clé API, les performances de différents modèles aux étapes de planification, d’implémentation et de revue. Une fois le bon candidat trouvé pour chaque rôle, figez la configuration : pour changer de modèle, il suffira de modifier le paramètre model.

/swarm : comment plusieurs agents collaborent sans se gêner mutuellement

Le tableau de messages partagé : la communication ouverte entre agents

Les agents utilisent tous un même tableau de messages en ajout seul (Shared Message Board), sur lequel sont consignés le déroulement de la collaboration et l’avancement des tâches. Les messages ne font que s’empiler, ils ne s’écrasent jamais : l’historique complet des échanges de l’équipe reste donc entièrement traçable. Un agent peut se mettre en veille pendant qu’il attend les autres membres, puis être réveillé au moment où sa contribution devient nécessaire — Google indique qu’une attente passive ne consomme pas de tokens.

Ce choix est bien plus transparent que de laisser les agents s’appeler discrètement entre eux. Les retours du Verifier au Worker, les décisions d’ordonnancement du Coordinator : tout est étalé au grand jour, et l’utilisateur qui revient sur le déroulé voit précisément à quelle étape le problème est apparu.

Espace de travail partagé ou copie de travail individuelle : la distinction à ne pas rater

C’est le point sur lequel le blog officiel et la documentation divergent, et où il est très facile d’écrire une bêtise. Le blog met en avant le fait que les Workers parallèles peuvent travailler dans des Git Worktrees isolés, pour éviter de modifier le même répertoire en même temps. La documentation, elle, donne des règles plus fines :

• Par défaut : les Workers partagent l’espace de travail courant.
• Isolation à la demande : quand plusieurs Workers doivent modifier ou compiler le projet en simultané, le Coordinator peut leur attribuer des copies de travail distinctes du code.
• Suppression = perte : retirer un Worker supprime sa copie de travail, il faut donc d’abord fusionner ou committer ses résultats.

La formulation juste est donc celle-ci : le système met en place des copies de travail isolées en fonction des besoins des tâches parallèles, et non chaque agent ne dispose d’emblée de son propre Git Worktree totalement séparé. Pour une tâche d’investigation qui ne touche à aucun fichier, l’espace partagé suffit largement ; quand plusieurs Workers modifient du code et lancent des builds en parallèle, des copies séparées limitent les conflits de fichiers.

Comment observer et contrôler une équipe /swarm dans Antigravity

Quand plusieurs agents travaillent en parallèle, le plus frustrant pour l’utilisateur, c’est de ne pas savoir ce qui se passe à l’intérieur. Antigravity propose pour cela trois vues principales, avec des raccourcis équivalents dans la CLI.

Votre contrôle ne se limite pas à regarder le résultat final. Grâce à ces accès, vous pouvez examiner le parcours de travail de chaque agent, entrer dans un Worker pour intervenir directement, ou encore ajuster les consignes données au Coordinator. Les raccourcis Alt + J et Ctrl + K montrent que l’approbation des appels d’outils reste entre les mains de l’humain : lorsqu’un agent doit effectuer une opération sensible, il s’arrête et attend votre confirmation.

Quelles tâches d’ingénierie complexes /swarm peut-il traiter

Google cite trois grandes familles de cas d’usage internes : les migrations multi-packages, les enquêtes de cause racine à travers plusieurs sous-systèmes et la refonte d’architectures logicielles complexes. Leur point commun : un volume de travail important, décomposable, et qui demande de la vérification.

Les exemples de la documentation officielle sont plus proches du développement quotidien :

• modifier plusieurs API Handlers séparément, en configurant des tests pour chacun ;
• enquêter en parallèle sur les causes profondes d’un démarrage lent du CLI ;
• regrouper les tests en échec d’un gros projet par package et les répartir entre différents agents pour les corriger ;
• confier à des modèles distincts l’implémentation du code et sa vérification indépendante.

Google a aussi présenté une démo officielle : grâce à la collaboration multi-agents d’Antigravity, Carbon a traité 7 PDF publics de planification urbaine, en a extrait 206 vues de plans techniques et généré au final un modèle de bâtiment Three.js interactif d’environ 906 000 triangles, le tout sur 10 itérations nocturnes. C’est un cas officiel Google, donc pas une validation tierce indépendante, mais il montre bien comment plusieurs agents se répartissent le travail sur des tâches de longue haleine.

Coût, permissions et limites de la Preview de /swarm

Consommation de quota avec plusieurs agents

Un agent qui attend sans rien faire ne consomme pas de token, mais cela ne veut pas dire que /swarm revient moins cher. Chaque worker est un agent à part entière : quand plusieurs membres travaillent en même temps, le quota global part nettement plus vite que dans une conversation unique. Google le signale d’ailleurs elle-même.

Il y a un autre piège facile à rencontrer : un worker qui épuise son quota se met en pause, et une fois le quota rétabli, il ne reprend pas automatiquement — il faut intervenir à la main. Avant de lancer une grosse tâche de longue durée, mieux vaut estimer si le quota suffira.

Permission sur la fonction Swarm ≠ permission sur le modèle Carbon

C’est le point le plus souvent confondu. Pouvoir utiliser /swarm ne signifie pas pouvoir utiliser Carbon à l’intérieur de Swarm.

Autrement dit, un utilisateur Pro peut tester le mécanisme de collaboration de Swarm, mais les modèles auxquels les agents ont accès restent soumis aux droits propres à chaque abonnement.

Analyse d’impact : /swarm fait passer la programmation IA de l’assistant à l’équipe

Impact pour les développeurs

• Changement de rôle : le développeur passe de « celui qui interroge le modèle » à « celui qui organise une équipe d’IA ». La qualité du découpage des tâches et les critères d’acceptation pèsent directement sur le résultat.
• Validation en amont : le mécanisme Verifier inscrit les tests et la revue dans le déroulé par défaut du processus — ce n’est plus un rattrapage effectué après la génération.
• La gestion des coûts devient un vrai sujet : plusieurs Workers en parallèle, cela veut dire surveiller les quotas, l’assemblage des modèles et la granularité des tâches. On ne peut plus se contenter de juger l’expérience d’une conversation isolée.

Impact pour le secteur

• La collaboration multi-modèles s’impose comme axe de déploiement : un modèle puissant pour la planification et la revue, des modèles rapides pour l’exécution en volume. De plus en plus de frameworks d’agents vont reprendre cette répartition.
• La concurrence se déplace vers la livraison de tâches : l’affrontement entre modèles quitte les scores de questions-réponses en un seul tour pour se porter sur la capacité à planifier, exécuter, vérifier et livrer sur des tâches de longue durée.

Reproduire l’approche /swarm multi-agents avec une API : exemple minimaliste

Si vous voulez tester dans votre propre projet le principe « un coordinateur découpe, des workers exécutent », vous pouvez écrire un prototype minimal avec une interface compatible OpenAI. Le code ci-dessous illustre uniquement la structure de collaboration : ce n’est pas l’implémentation de /swarm d’Antigravity. Pensez à remplacer les noms de modèles par ceux qui sont disponibles sur votre compte.

from openai import OpenAI

client = OpenAI(api_key="YOUR_API_KEY", base_url="https://api.apiyi.com/v1")

def ask(model, prompt):
    resp = client.chat.completions.create(
        model=model, messages=[{"role": "user", "content": prompt}]
    )
    return resp.choices[0].message.content

plan = ask("STRONG_MODEL", "把“修复 3 个 API Handler 的失败测试”拆成独立子任务，每行一个")
for task in [t for t in plan.splitlines() if t.strip()]:
    print(ask("FAST_MODEL", f"完成这个子任务并给出补丁：{task}"))

import concurrent.futures as cf
from openai import OpenAI

client = OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.apiyi.com/v1"  # Interface compatible OpenAI d'APIYI
)

COORDINATOR_MODEL = "STRONG_MODEL"   # Planification et synthèse : à remplacer par un modèle doué en raisonnement
WORKER_MODEL = "FAST_MODEL"          # Exécution en lot : à remplacer par un modèle rapide et léger
VERIFIER_MODEL = "REVIEW_MODEL"      # Relecture indépendante : de préférence différent du Worker
board = []                           # Tableau de messages partagé, en ajout seul

def ask(model, system, prompt):
    resp = client.chat.completions.create(
        model=model,
        messages=[{"role": "system", "content": system},
                  {"role": "user", "content": prompt}],
    )
    return resp.choices[0].message.content

def worker(task, max_rounds=3):
    patch = ask(WORKER_MODEL, "你是 Worker，只负责分配给你的子任务。", task)
    for i in range(max_rounds):
        review = ask(VERIFIER_MODEL,
                     "你是 Verifier，检查补丁问题。没有问题只回复 PASS。",
                     f"任务：{task}\n补丁：\n{patch}")
        board.append(f"[Verifier] {task[:20]}... 第{i+1}轮：{review[:60]}")
        if review.strip().startswith("PASS"):
            return patch
        patch = ask(WORKER_MODEL, "根据审查意见修复补丁。",
                    f"任务：{task}\n原补丁：{patch}\n意见：{review}")
    return patch + "\n# 未通过验证，需人工检查"

goal = "为 users、orders、payments 三个 API Handler 补充输入校验并修复失败测试"
plan = ask(COORDINATOR_MODEL, "你是 Coordinator，把目标拆成互不重叠的子任务，每行一个。", goal)
tasks = [t.strip() for t in plan.splitlines() if t.strip()]
board.append(f"[Coordinator] 拆分为 {len(tasks)} 个子任务")

with cf.ThreadPoolExecutor(max_workers=4) as pool:
    results = list(pool.map(worker, tasks))

summary = ask(COORDINATOR_MODEL, "汇总各 Worker 结果，列出完成情况与风险。",
              "\n\n".join(results))
print("\n".join(board))
print(summary)

🚀 Démarrage rapide : pour monter ce type de prototype multi-rôles, nous vous conseillons de récupérer votre clé API et un crédit de test gratuit pour les nouveaux utilisateurs sur APIYI (apiyi.com). La plateforme propose une interface compatible OpenAI : vous pouvez appeler les modèles d’OpenAI, de Claude, de Gemini et d’autres avec un seul et même code, et vérifier facilement si la combinaison « un modèle puissant pour planifier, un modèle rapide pour exécuter, un modèle hétérogène pour relire » convient à votre projet.

Questions fréquentes (FAQ)

Google Antigravity /swarm : les points clés (Key Takeaways)

• Mécanisme d’exécution : /swarm <task> transforme la conversation en cours en Coordinator, qui découpe la tâche et crée des Workers indépendants
• Répartition typique : Coordinator, Worker, Verifier, Monitor, avec en général un Verifier pour 2 à 4 Workers
• Mode de collaboration : un tableau de messages partagé en ajout seul (append-only) sert à communiquer ouvertement, et les agents inactifs en attente ne consomment aucun token
• Règles d’espace de travail : espace de travail partagé par défaut ; en cas de modifications parallèles, des copies de travail indépendantes sont attribuées selon les besoins
• Contrôle visuel : trois vues (Board, Members, Graph), complétées par des commandes CLI comme /swarm board ou /agents
• Limites actuelles : toujours en Preview, les quotas fondent vite avec plusieurs Workers, et les permissions Swarm ne sont pas équivalentes aux permissions Carbon
• Mise en pratique maison : avec APIYI (apiyi.com) et son interface unifiée, vous pouvez combiner plusieurs modèles pour construire votre propre prototype multi-rôles

Conclusion

Ce qu’il faut retenir de Google Antigravity /swarm :

1. Du parallélisme à la collaboration : l’intérêt de /swarm ne se limite pas à l’exécution en parallèle. C’est la boucle complète qui compte : découpage des tâches, contextes indépendants, vérification contradictoire et suivi de l’avancement.
2. Isolation à la carte : l’espace de travail partagé et les copies de travail indépendantes s’alternent selon les besoins de la tâche, et il faut donc surveiller le moment des fusions.
3. Capacités et coûts vont de pair : les systèmes multi-agents permettent de traiter des tâches d’ingénierie plus complexes, mais ils consomment plus de quota et rendent la gestion des ressources plus compliquée. Pour l’instant, on reste en Preview.

Pour les développeurs, /swarm change concrètement la façon de travailler : il ne s’agit plus seulement de poser des questions à un modèle, mais d’organiser une équipe d’IA capable de se répartir le travail, d’exécuter, de vérifier et de livrer. Même si vous ne pouvez pas utiliser Antigravity pour le moment, l’idée d’« attribuer les modèles selon les rôles et de rendre la vérification indépendante de l’exécution » peut très bien s’appliquer à vos propres systèmes d’agents. Pour tester rapidement différentes combinaisons de modèles, je vous recommande APIYI (apiyi.com), qui propose un quota de test gratuit et une interface unifiée pour de nombreux modèles.

📚 Références

1. Documentation officielle de Google Antigravity Swarm : mécanisme d’exécution de /swarm, configuration des rôles, copies de travail et opérations en CLI
2. Lien : antigravity.google/docs/swarm

3. Description : source de première main sur le Coordinator, le Verifier et le Monitor, ainsi que sur les vues Board / Members / Graph

4. Blog officiel de Google Antigravity : Gemini 4 Carbon in Google Antigravity

5. Lien : antigravity.google/blog/gemini-4-carbon-in-google-antigravity

6. Description : informations sur la sortie de /swarm, architecture multi-agents et recommandations d’attribution des modèles selon les rôles

7. Annonce officielle de Google : Gemini 4 Carbon is now available

8. Lien : blog.google/innovation-and-ai/models-and-research/gemini-models/gemini-4-carbon-now-available

9. Description : périmètre d’ouverture officielle de Carbon et contexte de lancement de l’aperçu de /swarm

10. Page des avantages des abonnements Google AI : droits d’accès aux modèles pour AI Pro et Ultra

11. Lien : one.google.com/about/google-ai-plans

12. Description : distinction entre les niveaux d’abonnement et l’accès au modèle Carbon

13. Article de The Verge sur la sortie : Google releases Gemini 4 Carbon with agent swarm feature

14. Lien : theverge.com/ai-artificial-intelligence/1030787/google-gemini-4-carbon-public-rollout
15. Description : contexte du lancement et restrictions d’accès vus par un média indépendant

Auteur : l’équipe technique d’APIYI
Échanges techniques : n’hésitez pas à nous contacter sur la page d’accueil d’APIYI (apiyi.com) pour échanger sur vos pratiques multi-agents. Pour en savoir plus sur l’intégration, rendez-vous dans le centre de documentation : docs.apiyi.com

Articles connexes

• Décryptage du lancement de Gemini 4 Carbon : 59 points et une longueur d’avance sur Opus 5.5, 15 victoires sur 17, mais impossible à invoquer: Gemini 4 Carbon domine l’indice global d’intelligence d’Artificial Analysis avec 59 points et gagne 15 des 17 comparaisons officielles, mais n’a ni ID de modèle API ni calendrier d’accès ; cet article détaille les scores, son indisponibilité et l’alternative gemini-4-argon pour les développeurs chinois.