Comprendre Antigravity Orchestrator de zéro : architecture à 3 couches, 3 modes d’orchestration et mécanisme d’essaim en détail

Comprendre Antigravity Orchestrator de zéro : architecture à 3 couches, 3 modes d’orchestration et mécanisme d’essaim en détail

Note de l’auteur : un seul article pour comprendre ce qu’est Antigravity Orchestrator, comment déployer des sous-agents via /swarm, et ce qui le distingue de LangGraph et CrewAI en termes de positionnement.

Résumé : Antigravity Orchestrator est le moteur de coordination multi-agents intégré à la plateforme Google Antigravity, et non un framework léger que l’on pourrait installer séparément avec pip. Cet article aborde quatre aspects — la matrice produit, les trois niveaux d’abstraction, les trois modes d’orchestration et le mécanisme d’essaimage /swarm — pour vous aider à saisir clairement son fonctionnement et son périmètre d’usage.

La conclusion d’abord : on peut voir Antigravity Orchestrator comme « le cerveau d’ordonnancement des tâches caché au cœur de la plateforme Antigravity ». Quand vous tapez une commande slash comme /swarm ou /teamwork dans l’IDE, une application Web ou le CLI, il fait appel en coulisses à la Task API du SDK et au Workflow Runtime, découpe une grosse tâche en plusieurs sous-tâches, les confie à des sous-agents qui travaillent en parallèle, puis consolide le tout en livrables. En novembre 2026, l’Orchestrator intègre officiellement Antigravity aux côtés de Gemini 4 Neon. Le 10 novembre, lors de l’ouverture générale de Gemini 4 Carbon, Sundar Pichai a présenté en direct la capacité /swarm : c’est à ce moment que la fonctionnalité est entrée sous les projecteurs du public.

Cela vaut-il la peine d’y investir du temps d’apprentissage ? La réponse tient à deux conditions. Premièrement, votre tâche peut-elle être découpée en parties indépendantes les unes des autres, donc exécutables en parallèle ? Deuxièmement, pouvez-vous accepter une plateforme optimisée autour de Gemini et dont le moteur central est fermé ? Quand ces deux conditions sont réunies, l’Orchestrator réduit sensiblement le coût de mise en place d’une collaboration multi-agents. Si en revanche vous cherchez une solution indépendante du modèle et entièrement open source, des bibliothèques Python comme LangGraph ou CrewAI restent plus adaptées.

antigravity-orchestrator-explained-from-zero-fr-image-0


Table of Contents

Carte des connaissances et index de lecture d’Antigravity Orchestrator

Le tableau ci-dessous présente la structure des connaissances de l’article, les dépendances entre les sections et le problème que chacune d’elles résout. La progression générale va de « de quoi il fait partie » à « comment il fonctionne », puis à « faut-il l’adopter et comment démarrer ».

N° Thème Problème résolu Relation avec les sections voisines
1 Contexte de la plateforme Antigravity Dans quel écosystème de produits s’exécute l’Orchestrator Fournit le contexte de plateforme pour la section 2
2 Les trois niveaux d’abstraction de l’Orchestrator Ce qu’il est techniquement Les mécanismes des sections 3 et 4 reposent sur ces trois niveaux
3 Les trois modes d’orchestration Quelles différences entre /swarm, /teamwork et /run-workflow Parmi les trois modes, /swarm est approfondi dans la section 4
4 Le mécanisme d’essaim de /swarm Comment l’agent principal décompose les tâches et délègue aux sous-agents S’appuie sur des cas réels pour étayer la comparaison de la section 5
5 Comparaison avec LangGraph et autres frameworks Dans quels cas l’adopter, dans quels cas l’écarter Fournit les critères de décision et prépare le parcours de prise en main de la section 6
6 Parcours de prise en main et code Comment démarrer à partir de zéro Traduit les concepts vus précédemment au niveau du code
7 Bonnes pratiques et implications Comment maîtriser le choix des modèles, les permissions et les coûts Se conclut en recommandations concrètes et applicables

Si vous voulez simplement comprendre ce que c’est, les sections 1 à 3 suffisent. Si vous préparez un choix technique, concentrez-vous sur les sections 4 et 5. Si vous souhaitez passer directement à la pratique, rendez-vous aux sections 6 et 7.

🎯 Conseil technique : la façon la plus rapide de comprendre l’orchestration multi-agents est de dérouler vous-même une fois le flux complet « décomposition — exécution parallèle — agrégation ». La section 6.3 propose une implémentation simulée basée sur une interface compatible OpenAI : via APIYI (apiyi.com), une seule clé API suffit pour invoquer différents modèles jouant les rôles d’agent principal et de sous-agents.

To Know : le vocabulaire indispensable pour comprendre Antigravity Orchestrator

Terme Explication concise
Agent Instance de modèle capable d’appeler des outils et d’accomplir de manière autonome des tâches en plusieurs étapes
Agent principal (Orchestrator Agent) Coordinateur général chargé d’analyser et de décomposer les tâches, de déléguer aux sous-agents et de consolider les résultats
Sous-agent (Subagent) Agent qui prend en charge une sous-tâche ; il peut être créé dynamiquement à l’exécution ou défini à l’avance
Fan-out / Fan-in Le fan-out désigne la distribution d’une tâche à plusieurs exécutants ; le fan-in, la convergence des résultats vers un point unique
Artifacts Livrables finaux produits par les agents : code, fichiers, applications exécutables, etc.
Workflow Runtime Moteur d’exécution à base de graphes du SDK Antigravity, chargé de la gestion des états et de l’ordonnancement des nœuds

1 La plateforme où vit Antigravity Orchestrator : qu’est-ce qu’Antigravity

1.1 D’où vient le nom Antigravity

« Antigravity » se traduit littéralement par « antigravité », avec l’idée de libérer le développement des contraintes du codage solitaire traditionnel — comme si l’on s’envolait en apesanteur. Nombreux sont les développeurs qui pensent que ce nom s’inspire de l’easter egg import antigravity de Python. Cet easter egg provient d’une bande dessinée xkcd : exécuter cette ligne de code ouvre le comic dans le navigateur. Google positionne Antigravity comme une plateforme de développeurs de l’« agent-first era » (l’ère des agents d’abord) : autrement dit, ce sont les agents qui font le travail, tandis que l’humain décrit les objectifs et valide les résultats.

1.2 Antigravity est une matrice de produits

Beaucoup, en découvrant Antigravity pour la première fois, le prennent pour un simple IDE. En réalité, il s’agit d’un ensemble de produits adaptés à différents scénarios, et les capacités d’Orchestrator se répartissent entre ces différentes déclinaisons :

Produit Forme Usage principal
Antigravity App Application Web Programmation agentique complète dans le navigateur
Antigravity IDE Application de bureau Fork de VS Code avec intégration approfondie des agents
Antigravity CLI Outil en ligne de commande Agent de terminal écrit en Go
Antigravity SDK Bibliothèque Python Développement d’agents personnalisés
Antigravity Extensions Extension IDE Intégrer les capacités d’agents aux éditeurs existants

Ce tableau révèle un fait essentiel : les commandes slash apparaissent dans les interfaces interactives comme l’App, l’IDE et le CLI, tandis que le SDK expose une interface programmable. Nous verrons à la section 2, consacrée aux trois niveaux d’abstraction, comment ces deux couches s’articulent.

1.3 La chronologie de lancement d’Antigravity Orchestrator

Orchestrator n’apparaît pas de nulle part : c’est le fruit d’une évolution progressive de la plateforme Antigravity sur une année. Voici, dans l’ordre chronologique, les étapes clés :

  • 18 novembre 2025 : lancement simultané d’Antigravity IDE et de Gemini 3 Pro le même jour.
  • Mai 2026 (Google I/O) : sortie de Gemini 3.5 Flash, ainsi que de Gemini Spark, basé sur le runtime Antigravity.
  • 18 juin 2026 : arrêt du service du Gemini CLI open source, migration complète vers l’Antigravity CLI propriétaire.
  • Novembre 2026 : arrivée officielle de Gemini 4 Neon et d’Orchestrator au sein d’Antigravity.
  • 10 novembre 2026 : ouverture complète de Gemini 4 Carbon, Sundar Pichai démontre /swarm.

Cette chronologie met en évidence une tendance claire : Google regroupe progressivement les capacités d’agents du terminal, de l’IDE et du navigateur sous le runtime Antigravity, Orchestrator constituant la couche de coordination qui vient se poser au-dessus de ce runtime.


2 Qu’est-ce qu’Antigravity Orchestrator : décryptage des trois couches d’abstraction

2.1 Ce qu’est vraiment Antigravity Orchestrator

Certains articles présentent Antigravity Orchestrator comme un « framework d’essaim léger ». Cette formule peut facilement faire croire à tort qu’il s’agit d’une bibliothèque indépendante. Une description plus juste : c’est le moteur de coordination multi-agents intégré à la plateforme Antigravity. En coulisses, il repose sur le Workflow Runtime et le Task API du SDK ; en surface, il se déclenche via des commandes slash ou l’API du SDK. Le qualificatif « léger » concerne l’expérience d’utilisation : une seule commande suffit, sans avoir à écrire à la main la structure du graphe ni les machines à états.

2.2 L’architecture en trois couches d’Antigravity Orchestrator

Les capacités de l’Orchestrator se répartissent en trois couches, de haut en bas. Chaque couche s’appuie sur celle du dessous, et plus on descend, plus on s’approche des détails d’exécution :

Layer 1 : commandes slash        /swarm, /teamwork, /plan
    ↓  côté utilisateur : une seule commande déclenche l'orchestration
Layer 2 : API du SDK             Agent, Subagent, Task API
    ↓  côté développeur : agents et tâches définis en code
Layer 3 : Workflow Runtime       moteur d'exécution de graphes, Fan-out/Fan-in, gestion d'état
       côté runtime : gère l'ordonnancement, le parallélisme et l'état

L’avantage direct de cette hiérarchie, c’est « un même moteur, plusieurs points d’entrée ». Un chef de produit peut taper directement /swarm dans son IDE, un ingénieur backend peut écrire la même logique d’orchestration avec le SDK ; dans les deux cas, c’est finalement le Workflow Runtime qui exécute. Une fois ce point compris, les différences entre les trois modes présentés plus loin deviennent limpides : ils ne sont que des points d’entrée différents à la Layer 1, et correspondent à des formes de graphe distinctes à la Layer 3.

antigravity-orchestrator-explained-from-zero-fr-image-1


3 Les trois modes d’orchestration d’Antigravity Orchestrator

Orchestrator propose trois modes d’orchestration, qui se distinguent sur deux points : la nécessité ou non d’interactions continues entre les sous-agents, et le fait que le processus soit déterminé à l’avance ou non. Choisir le mauvais mode est le piège le plus courant chez les débutants, donc commençons par une comparaison :

Mode Déclenchement Forme de collaboration Tâches adaptées
Swarm (essaim) /swarm Déploiement unique de plusieurs sous-agents travaillant en parallèle, puis consolidation des résultats Grandes tâches découpables en parties indépendantes
Teamwork (équipe) /teamwork Une équipe d’agents collabore en continu, sur plusieurs tours d’interaction Projets complexes nécessitant des discussions répétées et des dépendances mutuelles
Workflow (flux de travail) /run-workflow Graphe orienté prédéfini, prenant en charge branches, boucles et routage conditionnel Tâches au déroulement fixe, nécessitant des exécutions reproductibles

Pour vous décider, posez-vous les questions dans l’ordre suivant. Si le processus est identique à chaque fois, choisissez Workflow. Si le processus n’est pas figé, mais que les sous-tâches n’ont quasiment pas besoin de communiquer entre elles, choisissez Swarm. Si les sous-tâches doivent s’aligner en permanence — par exemple, quand le frontend modifie une interface et que le backend doit s’ajuster en conséquence — choisissez Teamwork. Swarm offre le parallélisme le plus élevé et le temps d’attente le plus court, mais c’est aussi le plus exigeant en matière de découpage des tâches.


4 Le mécanisme d’essaim /swarm d’Antigravity Orchestrator

4.1 Le workflow en cinq étapes de /swarm

/swarm est la fonctionnalité la plus emblématique d’Orchestrator, et son déroulé complet s’articule en cinq étapes :

  1. L’utilisateur lance la commande /swarm accompagnée d’une description de la tâche.
  2. L’agent principal (Orchestrator Agent) analyse la tâche et la décompose automatiquement en plusieurs sous-tâches.
  3. Des sous-agents sont créés dynamiquement pour chaque sous-tâche : c’est ce qu’on appelle les « sous-agents auto-clonés dynamiquement ».
  4. Les sous-agents s’exécutent en parallèle, et leurs résultats remontent vers l’agent principal.
  5. L’agent principal consolide les sorties et génère les Artifacts finaux.

Les étapes 2 et 5 déterminent la qualité finale. Une décomposition mal faite, et les sous-agents risquent de se recouvrir ou de laisser des trous ; une capacité d’intégration insuffisante, et les différents morceaux ne s’assemblent jamais en un tout utilisable. C’est pourquoi l’agent principal a généralement besoin d’un modèle au raisonnement plus puissant.

4.2 Sous-agents dynamiques et sous-agents statiques

Antigravity Orchestrator prend en charge deux types de sous-agents, qui peuvent être combinés au sein d’une même tâche :

  • Sous-agents auto-clonés dynamiquement : créés à la demande au moment de l’exécution, ils héritent d’une partie du contexte de l’agent principal et conviennent aux sous-tâches improvisées à la volée.
  • Sous-agents personnalisés statiques : agents spécialisés définis à l’avance, dotés d’instructions système et d’un ensemble d’outils fixes, ils se prêtent aux étapes expertes qui reviennent régulièrement, comme la revue de code ou la génération de tests.

Un autre choix de conception mérite l’attention : chaque sous-agent peut tourner sur un modèle différent. Par exemple, Carbon pour ce qui exige un raisonnement approfondi, Hydrogen pour ce qui est rapide et simple. Cette logique consistant à « attribuer un modèle selon la difficulté de la tâche » constitue le levier essentiel pour maîtriser les coûts d’un système multi-agents ; la section 7 y reviendra en détail.

4.3 Étude de cas : comment Pelican Campus Quest a été décomposé

La démonstration de /swarm faite par Sundar Pichai est un excellent cas d’école. La tâche confiée à l’agent principal : « construire un jeu 3D en monde ouvert permettant d’explorer le campus de Google à Mountain View en GBike ». Il l’a décomposée en trois axes parallèles :

  • Modélisation des assets 3D : le sous-agent travaille avec Blender, en s’appuyant sur les ressources générées par Omni / Nano Banana.
  • Construction du moteur de jeu : le sous-agent utilise Three.js et des shaders WebGL.
  • Système audio : le sous-agent s’appuie sur l’API Web Audio couplée à la musique de Lyria.

Au bout du compte, les trois parties sont automatiquement assemblées en un jeu jouable directement dans le navigateur. Si ce cas illustre si bien Swarm, c’est parce que les trois blocs — modèle, moteur et audio — n’ont qu’à convenir des formats au niveau des interfaces et n’ont pratiquement pas besoin d’attendre l’un l’autre en cours de développement : c’est exactement cette « décomposabilité » évoquée à la section 3.


5 Antigravity Orchestrator face à LangGraph, CrewAI et AutoGen

5.1 Critères de comparaison

La comparaison ci-dessous porte uniquement sur les différences de positionnement, sans évaluer les performances, car leurs formes sont radicalement différentes : l’une est une plateforme complète, les autres sont des bibliothèques Python. Les dimensions comparées incluent le positionnement produit, l’abstraction des agents, l’intégration navigateur, le couplage aux modèles, les modalités de déploiement et le degré d’ouverture du code.

antigravity-orchestrator-explained-from-zero-fr-image-2

Dimension Antigravity LangGraph CrewAI AutoGen
Positionnement IDE complet + plateforme Bibliothèque Python Bibliothèque Python Bibliothèque Python
Modèle d’agent Auto-clonage dynamique + statique Nœuds de graphe Définition de rôles Agents conversationnels
Intégration navigateur Extension Chrome native Aucune Aucune Aucune
Couplage aux modèles Optimisé pour Gemini Indépendant des modèles Indépendant des modèles Indépendant des modèles
Déploiement Cloud Run / Docker À déployer soi-même À déployer soi-même À déployer soi-même
Open source SDK open source, cœur propriétaire Entièrement open source Open source Open source
Recommandation multi-modèles Au sein de l’écosystème Gemini Accès unifié possible via APIYI apiyi.com Idem Idem

5.2 Critères de choix

LangGraph conserve une longueur d’avance sur le contrôle de la structure de graphe et l’open source intégral, mais vous devez construire vous-même l’intégration IDE, les opérations navigateur et la chaîne de déploiement. Antigravity Orchestrator prend l’avantage côté « prêt à l’emploi » : une seule commande /swarm suffit pour découper, paralléliser et consolider, avec en prime un pilotage natif du navigateur. CrewAI mise sur une définition de rôles intuitive, AutoGen excelle dans la collaboration pilotée par la conversation — et tous deux exigent de gérer soi-même le déploiement et la chaîne d’outils.

On peut en tirer une règle simple : si votre équipe utilise déjà Gemini en profondeur et veut des capacités multi-agents directement dans son IDE, choisissez Antigravity ; si vous devez passer d’un modèle à l’autre ou si l’auditabilité du moteur central est un critère important, tournez-vous vers les bibliothèques open source.

💡 Conseil de choix : si vous optez pour la voie des bibliothèques open source, unifiez de préférence la couche d’accès aux modèles avec une interface compatible OpenAI. Grâce à APIYI apiyi.com, une seule clé API suffit pour basculer entre GPT, Claude, Gemini et d’autres modèles dans LangGraph ou CrewAI — pratique pour attribuer des modèles différents aux différents nœuds d’un même graphe d’orchestration.


6 Parcours pour prendre en main Antigravity Orchestrator en partant de zéro

6.1 Ordre d’apprentissage recommandé

En suivant la logique « d’abord savoir l’utiliser, ensuite savoir l’écrire, enfin savoir l’optimiser », le parcours d’initiation se découpe en sept étapes :

  1. Concepts : comprendre ce qu’est Antigravity et pourquoi on en a besoin (sections 1 et 2 de cet article).
  2. Installation : trois méthodes au choix — Web App, téléchargement de l’IDE ou installation en ligne de commande.
  3. Premier agent : écrivez un agent Hello World avec le SDK.
  4. Comprendre l’Orchestrator : saisissez la relation entre le Workflow Runtime et le Task API.
  5. Premier Swarm : lancez /swarm en conditions réelles dans l’IDE ou en CLI.
  6. Approfondir les sous-agents : comparez l’efficacité des sous-agents dynamiques et statiques.
  7. Bonnes pratiques : choix du modèle, gestion des permissions et contrôle des coûts.

6.2 Écrire son premier agent avec le SDK Antigravity

Un agent minimal avec le SDK se résume à un objet de configuration et un seul appel de dialogue :

from google.antigravity import Agent, LocalAgentConfig

config = LocalAgentConfig(
    system_instructions="You are an expert assistant.",
)
async with Agent(config) as agent:
    response = await agent.chat("Hello!")
    print(await response.text())

Si vous souhaitez une sortie en streaming, il suffit d’itérer directement sur response. Ajouter des outils à votre agent est tout aussi simple : passez de simples fonctions Python au paramètre tools :

import sys

# Réponse en streaming
async for token in response:
    sys.stdout.write(token)
    sys.stdout.flush()

# Outil personnalisé
def get_weather(city: str) -> str:
    return f"It's sunny in {city}."

Les annotations de type dans la signature de la fonction aident l’agent à comprendre le rôle de chaque paramètre. Dans un projet réel, pensez à bien documenter vos fonctions outils avec des docstrings claires : ainsi, l’agent principal s’y retrouvera plus facilement pour décider quel outil confier à quel sous-agent au moment de décomposer la tâche.

6.3 Simuler le fan-out et le fan-in d’un essaim avec une interface compatible OpenAI

Le moteur central d’Orchestrator est propriétaire, mais l’approche « découper — paralléliser — consolider » peut être reproduite avec n’importe quel modèle. Le code ci-dessous simule une version minimale de /swarm : l’agent principal se charge de la décomposition et de la synthèse, tandis que les sous-agents travaillent en parallèle. Ce n’est pas une implémentation d’Antigravity, mais un exemple pédagogique destiné à éclairer le processus en cinq étapes de la section 4.1.

import asyncio
from openai import AsyncOpenAI

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

PLANNER_MODEL = "your-reasoning-model"  # agent principal : un modèle fort en raisonnement, à choisir dans la liste des modèles de la plateforme
WORKER_MODEL = "your-fast-model"        # sous-agent : un modèle rapide et peu coûteux

async def ask(model: str, system: str, prompt: str) -> str:
    resp = await client.chat.completions.create(
        model=model,
        messages=[{"role": "system", "content": system},
                  {"role": "user", "content": prompt}],
    )
    return resp.choices[0].message.content
Voir le code complet de la simulation d’essaim
import asyncio
from openai import AsyncOpenAI

client = AsyncOpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.apiyi.com/v1"  # une seule clé pour invoquer plusieurs modèles
)

PLANNER_MODEL = "your-reasoning-model"
WORKER_MODEL = "your-fast-model"

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

async def swarm(task: str, max_workers: int = 3) -> str:
    # Étape 2 : l'agent principal décompose la tâche (avant le fan-out)
    plan = await ask(
        PLANNER_MODEL,
        "你是主代理。把任务拆成互相独立、可并行的子任务,每行一个,不要编号。",
        task,
    )
    subtasks = [s.strip("- ").strip() for s in plan.splitlines() if s.strip()]
    subtasks = subtasks[:max_workers]

    # Étapes 3-4 : créer un sous-agent par sous-tâche et les exécuter en parallèle (fan-out)
    results = await asyncio.gather(*[
        ask(WORKER_MODEL, "你是只负责单一子任务的子代理,输出简洁可交付的结果。", s)
        for s in subtasks
    ])

    # Étape 5 : l'agent principal consolide les résultats (fan-in)
    merged = "\n\n".join(f"【{s}】\n{r}" for s, r in zip(subtasks, results))
    return await ask(
        PLANNER_MODEL,
        "你是主代理。整合子代理的产出,消除重复与冲突,输出最终方案。",
        f"原始任务:{task}\n\n子代理产出:\n{merged}",
    )

if __name__ == "__main__":
    print(asyncio.run(swarm("为一个浏览器小游戏设计美术、玩法和音效三部分方案")))

Ce code illustre deux points essentiels : l’agent principal et les sous-agents utilisent des modèles distincts, et les sous-tâches s’exécutent en parallèle grâce à asyncio.gather. Mettez-le en regard de la section 4 et vous comprendrez tout ce qu’Orchestrator accomplit automatiquement pour vous dans la Layer 3 : gestion de l’état, relance en cas d’échec et consolidation des livrables.

🚀 Démarrage rapide : l’exemple ci-dessus s’exécute directement, il suffit de récupérer une clé sur APIYI (apiyi.com) et de remplacer les deux noms de modèles par des modèles disponibles sur la plateforme. Les nouveaux utilisateurs disposent d’un quota de test gratuit, largement suffisant pour quelques cycles de décomposition et de consolidation.


7 Bonnes pratiques et impact d’Antigravity Orchestrator

7.1 Choix des modèles : hiérarchiser selon la difficulté de la tâche

Dans un système multi-agents, les coûts grimpent en flèche avec le nombre de sous-agents : hiérarchiser les modèles est donc la première règle à appliquer. Confiez les étapes de décomposition et de synthèse, celles qui déterminent la qualité globale, à un modèle au raisonnement puissant, comme Carbon dans Antigravity ; et réservez la conversion de formats, le code boilerplate et les requêtes simples à un modèle rapide, comme Hydrogen. Pour reproduire une architecture similaire en dehors d’Antigravity, vous pouvez reprendre cette logique de niveaux telle quelle : via APIYI (apiyi.com), assignez un modèle différent à chaque rôle au sein d’un même code, comparez qualité et dépenses, puis figez la configuration.

7.2 Gestion des permissions : restreindre les outils des sous-agents

Les sous-agents dynamiques héritent d’une partie du contexte de l’agent principal. Si les permissions d’outils ne sont pas resserrées, un sous-agent peut effectuer des opérations qui dépassent son périmètre. L’approche la plus sûre consiste à regrouper les capacités d’écriture de fichiers, d’exécution de commandes et de pilotage du navigateur dans des sous-agents personnalisés statiques, avec des instructions système et un jeu d’outils clairement définis ; les sous-agents dynamiques, eux, se limitent à des tâches en lecture seule ou de génération. Toute opération touchant à l’environnement de production doit conserver une étape de validation humaine.

7.3 Maîtrise des coûts : estimer avant d’élargir le parallélisme

Plus le parallélisme de /swarm est élevé, plus le temps d’attente raccourcit… mais plus la consommation de tokens explose. Commencez par de petites tâches pour observer combien de sous-tâches l’agent principal décompose généralement et combien chacune en consomme, avant d’élargir à des tâches plus conséquentes. Pour les équipes sensibles au budget, validez d’abord votre stratégie de découpage avec des modèles économiques dans une bibliothèque d’orchestration open source : la facturation à l’usage d’APIYI (apiyi.com) facilite le contrôle des coûts d’expérimentation. Une fois le flux validé, migrez vers Antigravity pour bénéficier de l’ensemble des capacités de la plateforme.

7.4 L’impact d’Antigravity Orchestrator pour les développeurs

L’arrivée d’Orchestrator signe le passage d’une orchestration multi-agents « écrite à la main sous forme de graphes par les ingénieurs » à « déclenchée par une simple commande de l’utilisateur ». La barrière d’entrée baisse, mais la dépendance à la plateforme s’installe : le Gemini CLI open source n’est plus en service, le moteur central est fermé et optimisé avant tout pour Gemini. Pour les développeurs individuels et les équipes centrées sur Gemini, c’est un gain d’efficacité manifeste ; pour celles qui exigent le multi-modèles, l’auditabilité ou un déploiement privé, la combinaison d’un framework open source avec une couche d’accès unifiée aux modèles reste l’option la plus souple.

Au final, le test est simple : prenez une tâche réelle sur laquelle vous travaillez en ce moment et tentez de la découper en trois sous-tâches indépendantes les unes des autres. Si le découpage tient, /swarm vous fera probablement gagner beaucoup de temps ; s’il ne tient pas, les modes Teamwork ou Workflow, voire un agent unique, constituent un point de départ plus adapté.

antigravity-orchestrator-explained-from-zero-fr-image-3


Références

  1. xkcd 353 – Python : l’origine de l’easter egg import antigravity

    • Lien : xkcd.com/353
    • Description : pour comprendre l’origine culturelle du nom Antigravity
  2. Vidéo de prise en main de Google Antigravity : la démonstration officielle pour bien démarrer

    • Lien : youtube.com/watch?v=nTOVIGsqCuY
    • Description : idéale pour les développeurs qui découvrent Antigravity pour la première fois
  3. Tweet de Sundar Pichai : démonstration des capacités de /swarm

    • Lien : twitter.com/sundarpichai/status/2120198811297694192
    • Description : la démonstration officielle publiée lors de l’ouverture de Gemini 4 Carbon
  4. Pelican Campus Quest, version jouable : le jeu navigateur généré par /swarm

    • Lien : aistudio.google.com/apps/bundled/pelican-campus-quest
    • Description : pour découvrir concrètement le résultat final du mode essaim

Auteur : Équipe technique APIYI
Échanges techniques : n’hésitez pas à nous contacter depuis la page d’accueil d’APIYI (apiyi.com), et retrouvez davantage de ressources dans le centre de documentation docs.apiyi.com

Articles connexes

Publications similaires