Google Antigravity : développer avec des agents IA autonomes

Pendant des années, l’intelligence artificielle dans le code s’est résumée à une chose : compléter la ligne que vous étiez en train de taper. Google Antigravity propose un changement de nature. Présentée le 18 novembre 2025 en même temps que Gemini 3, c’est une plateforme de développement « agent-first » : au lieu d’assister votre frappe, elle exécute des tâches entières. Vous décrivez un objectif, et des agents autonomes planifient, écrivent le code, lancent le terminal, testent dans un navigateur, puis vous rendent des comptes sous forme de livrables vérifiables. Ce guide pose la carte complète de l’outil et vous oriente vers les tutoriels pas à pas qui vous feront construire, étape après étape, une vraie application avec ces agents.

Sommaire

• Par où commencer
• Pourquoi Antigravity change la donne
• Les concepts fondamentaux
• Le choix des modèles
• Vue d’ensemble pratique
• Sécurité et garde-fous
• Au-delà du bureau : la CLI et l’agent géré
• Situer Antigravity parmi les outils
• Erreurs fréquentes
• Questions fréquentes

🎯 Ce que ce parcours vous permettra de faire

• Installer Antigravity et déléguer une tâche complète à un agent autonome, sous votre contrôle.
• Orchestrer plusieurs agents en parallèle sur un même projet, sans bloquer votre éditeur.
• Juger le travail d’un agent à partir de ses livrables, et le corriger par commentaires ciblés.
• Cadrer durablement le comportement des agents avec des instructions, des règles et des routines.
• Étendre vos agents avec des compétences sur mesure et des outils externes via le protocole MCP.
• Faire intervenir un agent depuis le terminal, jusque dans des environnements automatisés.

🗺️ Par où commencer

Cette série est conçue comme un parcours progressif. Chaque tutoriel construit une brique d’une même application fil rouge — Suivi, un petit gestionnaire de tâches d’équipe avec une API et une interface web. Suivez-les dans l’ordre si vous débutez ; piochez à la carte si vous connaissez déjà les bases.

1. Installer Google Antigravity et lancer votre premier agent — l’installation, la connexion, et votre première tâche autonome.
2. Orchestrer plusieurs agents avec l’Agent Manager — faire travailler plusieurs agents en parallèle.
3. Vérifier le travail d’un agent : les artifacts — lire les livrables et corriger par commentaires.
4. Cadrer un agent : AGENTS.md, Rules et Workflows — imposer vos conventions une fois pour toutes.
5. Créer une Skill et brancher un serveur MCP — ajouter savoir-faire et outils à vos agents.
6. Piloter Antigravity depuis le terminal : la CLI agy — les agents en ligne de commande et en automatisation.

Pourquoi Antigravity change la donne

Pour mesurer la rupture, il faut regarder ce qui précède. Les assistants de code de la génération précédente vivaient à l’intérieur de l’éditeur, en surimpression : ils suggéraient la suite d’une ligne, répondaient à une question dans un panneau, généraient une fonction sur demande. Utiles, mais fondamentalement passifs : c’était toujours vous qui teniez le volant, ligne après ligne.

Antigravity déplace le centre de gravité. L’agent n’est plus un outil dans votre boîte à outils ; il devient un acteur qui planifie et exécute des tâches de bout en bout. Pour cela, Google ne s’est pas contenté d’ajouter une fonctionnalité à un éditeur existant : la plateforme est un dérivé en profondeur de Visual Studio Code, repensé autour de l’agent. On y trouve une interface d’édition classique, certes, mais aussi une surface dédiée au pilotage d’agents, et surtout un accès direct, pour ces agents, à trois leviers d’action : l’éditeur, le terminal et le navigateur.

Cette capacité à agir sur les trois fronts est ce qui rend l’outil qualitativement différent. Un agent peut écrire du code, l’exécuter dans le terminal pour vérifier qu’il tourne, puis ouvrir un navigateur pour tester l’application comme le ferait un humain — cliquer, saisir, observer le résultat. Le tout en validant son propre travail au passage. On passe d’un assistant qui propose à un collaborateur qui réalise et contrôle. Cette puissance s’accompagne naturellement de responsabilités, et nous verrons que la maîtrise des garde-fous est aussi importante que celle des fonctionnalités.

Cette évolution s’inscrit dans une tendance de fond du développement logiciel : le déplacement progressif de l’effort humain, du « comment » vers le « quoi ». Pendant des décennies, programmer signifiait traduire une intention en instructions détaillées, ligne par ligne. Les agents autonomes ne suppriment pas cette traduction, mais ils la prennent largement en charge, laissant au développeur la part la plus noble du travail : décider de ce qu’il faut construire, fixer les critères de qualité, et arbitrer les choix. Loin de dévaloriser la compétence technique, ce mouvement la déplace vers le jugement et la conception. Comprendre Antigravity, ce n’est donc pas seulement apprendre un logiciel ; c’est se préparer à une façon de travailler qui s’installe durablement dans le métier.

Les concepts fondamentaux

Quelques notions structurent tout l’usage d’Antigravity. Les comprendre une fois rend la suite limpide.

Les deux surfaces de travail

Antigravity sépare volontairement deux espaces. L’Editor View est l’éditeur de code au sens classique : explorateur de fichiers, coloration, complétion en ligne, terminal intégré. C’est l’espace synchrone, où vous travaillez au plus près du code. L’Agent Manager est une tour de contrôle : on y lance plusieurs agents, on suit leur avancement et on lit leurs livrables, le tout de façon asynchrone, sans bloquer l’éditeur. Cette dualité n’est pas un détail d’interface ; elle reflète deux manières de travailler — la main sur le clavier d’un côté, la délégation observée de l’autre. Savoir laquelle utiliser à quel moment est l’une des premières compétences à acquérir, détaillée dans le tutoriel sur l’Agent Manager.

Les agents et leur autonomie

Un agent reçoit un objectif, élabore un plan, puis l’exécute en mobilisant éditeur, terminal et navigateur. Vous gardez la main grâce à un réglage central : le niveau d’autonomie, qui détermine à quel point l’agent peut agir sans vous demander. Du mode le plus prudent — l’agent valide presque tout — au mode le plus libre, en passant par un mode supervisé recommandé au début, ce curseur est votre principal levier de confiance. On l’installe et on le règle dès le premier tutoriel.

Les artifacts

Comment juger un travail qu’on n’a pas tapé soi-même ? Par la trace qu’il laisse. Antigravity matérialise le travail de l’agent sous forme d’artifacts : la liste des tâches, le plan d’implémentation, les différences de code, un récapitulatif, des captures d’écran, et même des enregistrements vidéo des tests menés dans un navigateur. Ces livrables transforment une exécution invisible en éléments examinables, et vous pouvez les annoter par des commentaires ciblés, à la manière d’un document partagé, pour faire itérer l’agent sans l’interrompre. C’est le cœur d’une relecture efficace, approfondi dans le tutoriel sur les artifacts.

L’apprentissage et la base de connaissances

Antigravity traite l’apprentissage comme une brique de base. Les agents peuvent enregistrer du contexte et des extraits utiles dans une base de connaissances, afin d’améliorer leurs tâches futures. Concrètement, plus vous travaillez sur un projet en explicitant vos attentes, plus les agents anticipent vos conventions au lieu d’attendre qu’on les leur rappelle. Cette mémoire de travail se cultive volontairement, notamment via les instructions et les compétences que nous verrons plus loin.

Le modèle mental : décrire, déléguer, vérifier

Si l’on devait résumer Antigravity en une boucle, ce serait celle-ci : décrire, déléguer, vérifier. Elle paraît évidente, mais elle réorganise en profondeur la façon de travailler, et la garder en tête évite la plupart des erreurs de débutant.

Décrire vient en premier, et c’est l’étape la plus sous-estimée. La qualité du résultat dépend directement de la clarté de la demande. Un objectif flou produit un travail flou ; un objectif précis, avec ses contraintes et ses critères de réussite, produit un travail exploitable. On apprend vite à formuler comme on briefe un collègue compétent mais nouveau : ce qu’il faut faire, ce qu’il ne faut pas toucher, et comment on saura que c’est réussi. Ce déplacement de l’effort — de la frappe vers la formulation — est l’une des grandes nouveautés du métier.

Déléguer vient ensuite, et suppose un lâcher-prise mesuré. On confie l’exécution à l’agent, on le laisse planifier et agir, sans reprendre la main à la moindre seconde. Le niveau d’autonomie et les permissions définissent jusqu’où va ce lâcher-prise ; bien réglés, ils permettent de déléguer sans angoisse, parce que l’agent demandera avant tout geste sensible.

Vérifier referme la boucle, et c’est elle qui rend l’ensemble fiable. On ne juge pas un agent sur sa promesse, mais sur ses livrables : plan, différences de code, captures, vidéos de test. Vérifier ne veut pas dire tout relire ; cela veut dire lire ce qu’il faut, là où ça compte, pour valider en confiance. Un praticien qui maîtrise ces trois temps tire d’Antigravity bien plus qu’un utilisateur qui se contente de lancer des prompts et d’espérer.

Le choix des modèles

Un agent vaut en partie ce que vaut le modèle qui le fait raisonner. Antigravity mise sur la liberté de choix : plusieurs modèles sont disponibles, et vous sélectionnez celui qui convient à la tâche dans la zone de saisie de l’agent. Au cœur du dispositif, la gamme Gemini 3 de Google, avec des quotas d’utilisation généreux pendant la préversion. La plateforme prend aussi en charge des modèles d’autres fournisseurs, notamment un modèle Claude Sonnet d’Anthropic et un modèle ouvert de la famille GPT-OSS.

Cette ouverture a une vertu pratique : vous n’êtes pas enfermé. Un modèle peut exceller sur le raisonnement complexe, un autre sur la rapidité, un autre encore être préféré pour des raisons de coût ou de disponibilité. Les noms et versions précis évoluent vite sur un domaine aussi récent ; retenez le principe plutôt que la liste figée, et vérifiez les modèles proposés au moment où vous lisez ces lignes directement dans le sélecteur de l’application. C’est cette capacité à choisir, tâche par tâche, qui distingue une plateforme d’un produit mono-modèle.

L’application fil rouge : Suivi

Apprendre un outil agentique sur un exemple jouet ne mène pas loin. C’est pourquoi toute la série construit une application unique, modeste mais réelle : Suivi, un gestionnaire de tâches d’équipe. Côté serveur, une API qui crée, liste, met à jour et marque des tâches comme terminées ; côté navigateur, une interface légère qui consomme cette API. Rien d’exotique : exactement le genre de petit projet qu’un développeur monte pour un besoin interne.

Ce choix n’est pas anodin. Suivi est assez simple pour qu’on en comprenne chaque ligne, et assez complet pour exercer toutes les capacités d’Antigravity : créer du code, le tester dans un terminal, vérifier l’interface dans un navigateur, refactoriser sur plusieurs fichiers, documenter. En suivant le parcours, vous ne collectionnez pas des fonctionnalités isolées : vous voyez une application naître, grandir et se consolider sous la conduite d’agents que vous pilotez. C’est cette continuité qui transforme une série de tutoriels en véritable apprentissage.

Vue d’ensemble pratique

Au-delà des concepts, à quoi ressemble une journée de travail avec Antigravity ? La série la décline en briques concrètes, toutes assemblées autour de l’application Suivi.

Tout commence par l’installation et la première tâche : on ouvre un dossier, on règle l’autonomie, on confie à un agent la création du squelette du projet, et on valide le résultat via son récapitulatif. Vient ensuite l’orchestration : plutôt que d’enchaîner les tâches une à une, on lance plusieurs agents en parallèle — l’un sur l’API, l’autre sur l’interface — en répartissant le travail par fichier pour éviter les collisions. Puis la vérification prend le relais : on apprend à lire un plan avant qu’une ligne ne soit écrite, à inspecter une différence de code pour repérer les effets de bord, et à regarder l’agent tester l’application dans un vrai navigateur.

La maturité arrive avec le cadrage : un fichier d’instructions à la racine du projet, des règles ciblées et des routines déclenchées d’un simple / font que chaque agent démarre déjà aligné sur vos exigences. On étend ensuite les agents avec des compétences sur mesure, chargées seulement quand elles sont pertinentes, et des serveurs MCP qui leur ouvrent de nouveaux outils. Enfin, on sort de l’interface graphique avec la ligne de commande, qui porte les agents jusque dans les serveurs distants et les pipelines automatisés. Chacune de ces briques fait l’objet d’un tutoriel dédié, et chacune réutilise les acquis de la précédente.

Sécurité et garde-fous

Un agent capable d’exécuter des commandes, d’écrire des fichiers et d’ouvrir un navigateur est puissant — donc à manier avec discernement. C’est sans doute le point le plus important de tout ce parcours, et il mérite qu’on s’y arrête sérieusement plutôt que de le traiter en note de bas de page.

Le premier garde-fou est le niveau d’autonomie. En le réglant sur un mode supervisé au début, vous obligez l’agent à vous demander avant chaque action sensible : installer un paquet, exécuter une commande, écrire hors du périmètre attendu. Vous voyez précisément ce qu’il s’apprête à faire, et rien ne s’exécute dans votre dos. C’est la meilleure façon d’apprendre à connaître le comportement de l’outil tout en gardant le contrôle.

Le second garde-fou est le système de permissions. Chaque autorisation s’exprime sous la forme d’une action appliquée à une cible — exécuter telle famille de commandes, lire tel fichier, accéder à tel domaine — et se range dans une liste « autoriser », « refuser » ou « demander ». À cela s’ajoutent la restriction de l’agent au dossier du projet par défaut et la possibilité d’exécuter les commandes dans un bac à sable. Le principe directeur est celui du moindre privilège : n’accordez que les droits strictement nécessaires à la tâche, et n’élargissez que lorsque le besoin est avéré.

Cette vigilance n’est pas théorique. Un agent autonome peut rencontrer, dans un fichier ou une page web, une instruction trompeuse glissée par un tiers, et l’interpréter comme une consigne. Restreindre les actions par défaut, demander confirmation pour les opérations à risque et borner l’accès aux fichiers ne sont donc pas des précautions excessives, mais les fondations d’un travail sérieux. La configuration de ces protections est détaillée dans le tutoriel sur le cadrage des agents.

Au-delà du bureau : la CLI et l’agent géré

Antigravity ne se limite pas à son application de bureau. L’écosystème s’est étendu pour porter les agents partout où le code vit, et deux extensions méritent d’être connues.

La première est l’Antigravity CLI, invoquée par la commande agy. Écrite en Go, elle démarre vite, consomme peu, et fonctionne dans des environnements sans interface graphique — serveurs distants, intégration continue, scripts. Elle reprend le socle de l’application de bureau, si bien que vos instructions, vos compétences et vos outils s’y appliquent à l’identique. Elle s’inscrit dans la continuité d’un outil antérieur, le Gemini CLI, dont elle prolonge les fonctionnalités ; pour les usages gratuits et grand public, l’ancien outil cesse progressivement de servir au profit de agy. C’est l’objet du tutoriel sur la ligne de commande.

La seconde est l’agent géré exposé via l’API Gemini : une variante où l’agent tourne dans un bac à sable Linux hébergé par Google, accessible par programmation, avec exécution de code, gestion de fichiers et accès au web. Cette voie s’adresse aux équipes qui veulent intégrer un agent autonome directement dans leurs propres applications, au-delà de l’usage interactif. Elle confirme une direction : l’agent d’Antigravity n’est pas seulement un produit que l’on ouvre, mais une capacité que l’on peut brancher.

Situer Antigravity parmi les outils

Faut-il pour autant jeter tous ses autres outils ? La réponse honnête est nuancée. Antigravity brille quand la tâche est assez large pour valoir une délégation : construire une fonctionnalité entière, mener une refactorisation transversale, tester une application de bout en bout. Pour une retouche minuscule que vous voulez voir s’appliquer sous vos yeux, un éditeur classique avec complétion reste parfois plus direct — et Antigravity inclut justement cet éditeur pour ces moments-là.

La bonne manière de voir les choses n’est donc pas « remplacer » mais « élargir l’éventail ». Vous gardez la frappe directe quand elle est la plus rapide, et vous déléguez dès que la tâche grandit ou que l’attente passive serait du temps perdu. Cette respiration entre travail rapproché et délégation observée est précisément ce que la double surface de l’outil rend possible. Sur un domaine qui évolue aussi vite, garder cet esprit pragmatique — utiliser chaque mode pour ce qu’il fait de mieux — vaut mieux que tout miser sur une seule façon de travailler.

Erreurs fréquentes

Questions fréquentes

Antigravity est-il gratuit ?
Pendant la préversion publique, l’usage est gratuit pour les particuliers, avec des quotas généreux sur les modèles Gemini. Ces conditions peuvent évoluer ; la page officielle fait foi.

Sur quels systèmes fonctionne-t-il ?
L’application de bureau est multiplateforme : Windows, macOS et Linux. La ligne de commande, écrite en Go, fonctionne en plus dans des environnements sans interface graphique.

Faut-il déjà connaître VS Code ?
C’est un avantage, car Antigravity en est un dérivé en profondeur : raccourcis, explorateur et extensions vous seront familiers. Mais l’assistant de configuration accompagne les débutants, et la série part de zéro.

Quel modèle choisir ?
Cela dépend de la tâche. La gamme Gemini 3 est au cœur de la plateforme, mais vous pouvez basculer vers d’autres modèles selon vos besoins de raisonnement, de rapidité ou de coût. Le sélecteur se trouve dans la zone de saisie de l’agent.

Un agent peut-il casser mon projet ?
Le risque existe avec tout outil capable d’écrire des fichiers, d’où l’importance du mode supervisé, des permissions et de la restriction au dossier du projet. Bien réglé, l’agent vous demande avant les actions sensibles et reste cantonné à ce que vous autorisez.

Par où débuter concrètement ?
Par le tutoriel d’installation. En une trentaine de minutes, vous aurez installé l’outil, réglé l’autonomie et fait réaliser une première tâche à un agent.

Ressources officielles

• Site officiel : antigravity.google
• Tutoriel pas-à-pas Google : Getting Started with Google Antigravity
• Annonce développeurs : Build with Google Antigravity
• Présentation de Gemini 3 pour les développeurs : blog.google