Google mise sur Antigravity parce qu’elle estime que le codage par IA va passer de la « complétion assistée » à la « collaboration autonome multi-agents ». À ce stade, la capacité d’un modèle pris isolément ne fait pas office de facteur décisif : l’essentiel est de pouvoir coordonner un ensemble d’agents pour accomplir des tâches d’ingénierie en parallèle. Antigravity est la plateforme full-stack que Google a conçue pour cela : au niveau supérieur, l’Orchestrator assure l’ordonnancement de l’exécution sous forme de graphe ; au niveau inférieur, Swarm répartit les tâches entre des sous-agents spécialisés ; le tout s’appuie sur les modèles Gemini, Google Cloud et l’écosystème Chrome. Le prix à payer est tout aussi clair : un cœur propriétaire, une surface d’attaque en sécurité plus étendue et une fragmentation de la gamme de produits. Ces trois problèmes influeront directement sur la volonté des développeurs de suivre le mouvement.
Ce que vous découvrirez en lisant cet article
- La chronologie et la signification du passage, en 2026, du Gemini CLI open source à l’Antigravity CLI propriétaire
- L’ampleur de l’adoption du codage agentique en interne chez Google, ainsi que les controverses publiques qui l’entourent
- Pourquoi Swarm est jugé supérieur à un agent unique, et quels sont les trois principes de conception de l’Orchestrator
- Le positionnement d’Antigravity par rapport aux produits de Microsoft, Anthropic, OpenAI, Cursor et Cognition
- Ce que révèle le cas de Linus Torvalds utilisant Antigravity, ainsi que les principaux risques de cette approche
Sommaire : nous commençons par un tableau des concepts et un aperçu des impacts pour vous donner les bases. La partie « Faits objectifs » revient successivement sur l’origine du nom, les données d’adoption interne chez Google, la migration du CLI, la conception technique d’Antigravity, le paysage concurrentiel et le cas Linus. La partie « Analyse et jugement » examine la pertinence et les limites de la philosophie Swarm, les avantages structurels de Google, la liste des risques, et propose aux développeurs des recommandations concrètes pour s’y préparer.

To Know : comprendre les concepts clés de Google Antigravity
| Concept | Explication brève |
|---|---|
| Antigravity | La gamme de produits de codage par agents IA de Google, couvrant l’App, l’IDE, le CLI, le SDK et les Extensions |
| import antigravity | Easter egg intégré à Python : son exécution ouvre le comic xkcd n° 353, symbolisant un « décollage » facile avec Python |
| Agentic Coding (codage agentique) | L’IA ne se contente pas de compléter du code : elle planifie de façon autonome, appelle des outils, exécute et itère pour mener la tâche à bien |
| Orchestrator (orchestrateur) | Composant de contrôle de niveau supérieur chargé de décomposer les tâches, de coordonner les sous-agents et d’agréger les résultats |
| Swarm (essaim) | Un mode de collaboration parallèle entre plusieurs sous-agents spécialisés, proposé sous la forme /swarm dans Antigravity |
| Exécution par graphe orienté | Le flux de tâches est organisé sous forme de graphe, avec prise en charge des branches, des fusions, des boucles et des retours, plutôt que des étapes linéaires fixes |
| HITL (Human-in-the-Loop) | Collaboration humain-machine : à des points clés, un humain confirme, approuve ou examine la production de l’agent |
| MCP | Model Context Protocol, destiné à permettre aux agents de se connecter de manière unifiée à des outils et sources de données externes |
| Prompt Injection | Une attaque qui consiste à amener l’agent, via du contenu malveillant, à exécuter des opérations non prévues |
Aperçu rapide de l’impact de Google Antigravity
| Public | Impact principal |
|---|---|
| Développeurs ordinaires | La façon de coder passe de « écrire du code + interroger l’IA » à « décrire un objectif + réviser ce que produit l’agent » : l’importance de la capacité de revue augmente |
| Utilisateurs de Gemini CLI | Le service d’abonnement IA du Gemini CLI open source a cessé le 18 juin 2026 ; il faut migrer vers Antigravity CLI ou changer d’outil |
| Responsables techniques d’équipe | Il faut réévaluer la politique de permissions, les frontières de sécurité et le risque de verrouillage fournisseur, au lieu de regarder uniquement les capacités du modèle |
| Communauté open source | L’outil central passe de l’open source au code fermé ; l’espace de participation et d’audit de la communauté se réduit |
| Ingénieurs travaillant hors de leur langage principal | La barrière pour développer de petits outils multi-langages et multi-domaines baisse nettement ; le cas de Linus en est un exemple typique |
Les faits objectifs derrière le pari de Google sur Antigravity
Origine du nom Antigravity : d’un Easter egg Python à la philosophie produit
Le terme « antigravity » vient d’un Easter egg classique de la communauté Python. En Python, exécuter import antigravity ouvre la bande dessinée xkcd n° 353 : un personnage y vole dans les airs et, à quelqu’un qui lui demande comment il fait, il répond « Python ! ». Google a repris ce nom pour suggérer que les développeurs peuvent eux aussi « décoller » des tâches répétitives.
Du point de vue du positionnement produit, ce nom marque le passage d’un codage assisté par IA façon Copilot à une ère d’agents où l’IA accomplit les tâches de manière autonome. L’évolution technologique décrite dans les références peut se résumer en trois phases :
- L’ère Copilot (2021–2024) : complétion sur une ligne → suggestions multi-lignes → barre latérale Chat
- L’ère des agents (2024–2025) : agents autonomes et boucles agentiques, avec Devin et Cursor Agent comme exemples représentatifs
- L’ère Swarm (2025–2026 et au-delà) : collaboration multi-agents représentée par Antigravity /swarm, avec pour objectif de former une « équipe d’ingénierie virtuelle »

L’ampleur de l’adoption d’Antigravity chez Google et les controverses
Addy Osmani, directeur de l’ingénierie chez Google, a déclaré publiquement que plus de 40 000 ingénieurs logiciels utilisent chaque semaine le codage agentique. Il a également indiqué que les employés de Google peuvent utiliser des versions internes d’Antigravity, de Gemini CLI, des modèles personnalisés, des skills, des CLI et MCP, et que des systèmes comme Orchestrator, les boucles d’agents et les équipes SWE virtuelles sont déjà déployés en interne.
La controverse vient de Steve Yegge, un ancien ingénieur de Google. Selon lui, l’adoption de l’IA chez Google ressemble à peu près à celle des entreprises traditionnelles : environ 20 % d’utilisateurs intensifs, 20 % qui refusent de l’utiliser et 60 % qui se contentent des outils de base. Demis Hassabis, PDG de Google DeepMind, a lui-même répondu en qualifiant ce billet de « totalement faux, pur appât à clics ». Il est rare qu’un dirigeant de ce niveau intervienne pour réfuter une publication sur les réseaux sociaux ; cela montre indirectement l’importance que Google accorde au discours autour du codage agentique.
Migration de Gemini CLI vers Antigravity CLI
En mai 2026, Google a annoncé sur son blog développeurs que Gemini CLI, un outil open source écrit en TypeScript et publié sous licence Apache 2.0, cesserait son service d’abonnement IA le 18 juin, et que les utilisateurs migreraient entièrement vers Antigravity CLI, un outil closed source écrit en Go. À la date de publication de cet article, en novembre 2026, cette migration est effective depuis plusieurs mois.
Cette migration s’accompagne de trois changements notables : la stack technique passe de TypeScript à Go, le modèle de licence passe de l’open source au closed source, et le positionnement évolue d’une expérimentation communautaire vers un produit commercial central.
Les trois principes de conception de l’Orchestrator d’Antigravity
D’après les éléments rassemblés, l’Orchestrator d’Antigravity reflète trois orientations de conception :
- Exécution par graphe plutôt que flux linéaire : les frameworks d’agents traditionnels exécutent le plus souvent les étapes dans l’ordre étape 1 → étape 2 → étape 3 ; Antigravity adopte une exécution par graphe orienté, avec prise en charge des branches, des fusions, des boucles et des retours en arrière. Son innovation clé réside dans les « nœuds dynamiques » : l’étape suivante est décidée à l’exécution, et non précompilée à l’avance.
- Déclaratif plutôt qu’impératif : les développeurs définissent les capacités, les outils et les permissions de l’agent ; la manière dont les tâches sont accomplies est décidée par l’agent lui-même.
- Le HITL comme citoyen de première classe : grâce au mode ask_user du système Policies, au flux de confirmation des outils (Tool Confirmation Flow) et à l’Artifact Review après achèvement, la revue humaine est intégrée au processus.
Les éléments sources fournissent un exemple de code de configuration déclarative qui illustre cette approche :
# Déclaratif : définir les capacités et permissions de l'agent (exemple de code issu des sources, pas une utilisation complète du SDK)
config = LocalAgentConfig(
system_instructions="You are an expert...",
tools=[get_weather, search_code],
policies=[deny("run_command"), allow("view_file")],
)
# L'agent décide lui-même comment accomplir la tâche
Cette configuration ne contient aucune description d’étapes du type « d’abord ceci, ensuite cela » ; elle délimite uniquement l’étendue des capacités (tools) et les frontières des permissions (policies). Interdire l’exécution de commandes et autoriser la consultation de fichiers : cette écriture « liste blanche + liste noire » constitue précisément la base de la mise en œuvre du HITL et des politiques de sécurité.

Positionnement d’Antigravity face à ses concurrents
| Concurrent | Produit phare | Produit équivalent chez Google |
|---|---|---|
| Microsoft / GitHub | Copilot + Copilot Agent | Antigravity IDE + Extensions |
| Anthropic | Claude Code + Agent SDK | Antigravity SDK + CLI |
| OpenAI | Codex CLI + Swarm | Antigravity /swarm + CLI |
| Cursor | Cursor IDE | Antigravity IDE (fork de VS Code) |
| Cognition | Devin | Antigravity /swarm + Orchestrator |
On le voit dans ce tableau : Google ne vise pas un seul adversaire, mais répond à chaque segment avec cinq lignes de produits. L’IDE Antigravity repose sur un fork de VS Code, exactement comme la démarche de Cursor.
Linus Torvalds écrit du Python avec Antigravity
Le 11 janvier 2026, Linus Torvalds a noté dans le README de son projet AudioNoise que l’outil de visualisation Python du projet avait « essentiellement été écrit en vibe-coding ». Il raconte qu’il connaît mieux les filtres analogiques que Python, et qu’au début il s’y prenait en « cherchant, puis en imitant le modèle », avant de finalement « supprimer l’intermédiaire — c’est-à-dire moi-même » et de réaliser directement l’outil de visualisation des échantillons audio avec Google Antigravity. Simon Willison en a ensuite parlé sur son blog.
Les problèmes de sécurité déjà exposés par Antigravity
En novembre 2025, Simon Willison a publié une analyse des risques de fuite de données liés à Google Antigravity. Les sources citées soulignent également que certaines surfaces d’attaque, comme l’injection de prompt, ont déjà été confirmées à plusieurs reprises. Autrement dit, dès qu’un agent peut lire des fichiers, exécuter des commandes et accéder à des pages web, la sécurité cesse d’être une question purement théorique.
L’analyse du pari de Google sur Antigravity
Constat n°1 : Swarm résout le goulot d’étranglement structurel de l’agent unique
Les limites d’un agent unique ne tiennent pas seulement au fait que « le modèle n’est pas assez intelligent » : il s’agit surtout d’un problème structurel. La fenêtre de contexte a un plafond, une tâche complexe exige en même temps des compétences variées (recherche, implémentation, tests, documentation), et les tâches longues souffrent facilement d’une atténuation de l’attention et d’hallucinations. Empiler simplement les paramètres d’un grand modèle de langage ne permet pas de résoudre ces trois problèmes à la fois.
L’approche Swarm s’inspire de la collaboration décentralisée des essaims d’abeilles et des colonies de fourmis : on découpe la grande tâche en morceaux, chaque sous-agent ne couvre qu’un domaine étroit, les exécutions peuvent être parallèles, et la défaillance d’un seul point ne fait pas s’effondrer l’ensemble. Le tableau ci-dessous compare les deux modes :
| Dimension | Agent unique (Single Agent) | Essaim (Swarm) |
|---|---|---|
| Pression sur le contexte | Toutes les informations s’entassent dans une seule fenêtre | Chaque sous-agent ne détient qu’un contexte local |
| Degré de spécialisation | Un seul agent doit jongler avec plusieurs capacités | Les sous-agents se concentrent sur un seul domaine étroit |
| Efficacité d’exécution | Progression séquentielle, la durée croît linéairement avec la tâche | Sous-tâches en parallèle, durée totale nettement réduite |
| Tolérance aux pannes | Une erreur en cours de route impose souvent de tout reprendre | L’échec d’un sous-agent peut être réessayé localement |
| Coût principal | Dégradation de la qualité sur les tâches longues | Surcoût d’orchestration, problèmes de cohérence des résultats et hausse des coûts |
Il faut le souligner : l’avantage de Swarm reste conditionnel. Si la tâche elle-même est difficile à découper et que les sous-tâches sont fortement couplées, le coût de coordination induit par le parallélisme peut annuler le gain. C’est donc la capacité de décomposition et de recomposition de l’Orchestrator qui conditionne cette philosophie — ce qui explique aussi pourquoi Google place l’exécution de graphes et les nœuds dynamiques au cœur du dispositif.

Deuxième constat : la stratification multi-modèles est le carburant de Swarm
L’autre prémisse implicite de Swarm, c’est la diversité des modèles. Chaque sous-agent n’a pas besoin du modèle le plus puissant et le plus coûteux. Les tâches comme la recherche de code ou la mise en forme conviennent à des modèles légers ; seuls la conception d’architecture et le débogage complexe justifient le recours à un modèle phare. Le matériel source évoque la stratégie de stratification Carbon / Neon / Hydrogen de la matrice de modèles Gemini, qui fournit précisément à Swarm des « profils métier » de différents calibres.
Cette approche n’est pas réservée à l’écosystème Google. Les développeurs qui construisent eux-mêmes des workflows multi-agents peuvent aussi attribuer différents modèles aux sous-agents selon la difficulté de la tâche. Le tableau ci-dessous propose une logique de stratification générique ; les noms de modèles à utiliser sont ceux réellement pris en charge par chaque plateforme :
| Rôle du sous-agent | Exigences de capacité | Logique de choix du modèle | Mode d’appel indicatif |
|---|---|---|---|
| Orchestration / planification des tâches | Fort raisonnement, longue fenêtre de contexte | Modèle phare | Interface unifiée APIYI apiyi.com |
| Implémentation de code | Bonnes capacités de code, stabilité | Modèle principal aux performances de code remarquables | Même clé API, changer le nom du modèle |
| Recherche / résumé / mise en forme | Rapide, peu coûteux | Modèle léger | Facturation à l’usage, adaptée aux sous-tâches fréquentes |
| Relecture des résultats | Validation croisée avec le modèle d’implémentation | Modèles de fournisseurs différents | Comparaison entre fournisseurs pour réduire les biais de même origine |
Faire appel à des modèles de fournisseurs différents pour une relecture croisée est une pratique courante pour réduire les angles morts du type « un modèle se vérifie lui-même ». Si vous voulez valider cette conception par couches sans multiplier les SDK, vous pouvez passer par une interface d’agrégation compatible OpenAI. Voici un exemple minimal montrant comment un même client appelle différents modèles pour réaliser une collaboration en deux étapes « implémentation + relecture » :
import openai
client = openai.OpenAI(
api_key="YOUR_API_KEY",
base_url="https://api.apiyi.com/v1" # Interface compatible OpenAI d’APIYI
)
def ask(model: str, prompt: str) -> str:
resp = client.chat.completions.create(
model=model,
messages=[{"role": "user", "content": prompt}]
)
return resp.choices[0].message.content
# Remplacez le nom du modèle par un nom réellement disponible dans la liste de modèles de la plateforme
code = ask("gemini-2.5-pro", "用 Python 写一个读取 WAV 并绘制波形的函数")
review = ask("claude-sonnet-4-20250514", f"审查以下代码的潜在问题:\n{code}")
print(review)
Voir l’exemple complet : implémentation simplifiée d’un « orchestrateur + sous-agents parallèles »
import openai
from concurrent.futures import ThreadPoolExecutor
client = openai.OpenAI(
api_key="YOUR_API_KEY",
base_url="https://api.apiyi.com/v1" # APIYI : accès unifié à plusieurs modèles
)
# Correspondance rôle de sous-agent -> modèle (les noms doivent correspondre à ceux réellement pris en charge par la plateforme)
AGENTS = {
"planner": "gemini-2.5-pro",
"coder": "claude-sonnet-4-20250514",
"reviewer": "gpt-4o",
}
def call(model: str, system: str, prompt: str) -> str:
resp = client.chat.completions.create(
model=model,
messages=[
{"role": "system", "content": system},
{"role": "user", "content": prompt},
],
)
return resp.choices[0].message.content
def orchestrate(goal: str) -> dict:
# 1. Planification : décomposer en sous-tâches (une par ligne)
plan = call(AGENTS["planner"],
"你是任务编排器,把目标拆成 3 个可独立完成的子任务,每行一个。",
goal)
subtasks = [s.strip() for s in plan.splitlines() if s.strip()][:3]
# 2. Exécution parallèle : sous-agents à la Swarm
with ThreadPoolExecutor(max_workers=3) as pool:
results = list(pool.map(
lambda t: call(AGENTS["coder"], "你是专注单一子任务的工程师。", t),
subtasks))
# 3. Révision : vérification croisée automatique avant la revue humaine
merged = "\n\n".join(results)
review = call(AGENTS["reviewer"],
"你是代码审查者,指出风险并给出修改建议。", merged)
return {"subtasks": subtasks, "results": results, "review": review}
if __name__ == "__main__":
out = orchestrate("实现一个音频采样可视化的命令行小工具")
print(out["review"])
Cet exemple ne fait que simuler de manière minimaliste le déroulement « planification → parallélisation → révision » ; il n’inclut ni les nœuds dynamiques, ni les mécanismes de repli, ni les politiques de permissions d’Antigravity. Pour une véritable utilisation en production, il faudra encore ajouter la reprise sur échec, la validation de la fusion des résultats et une étape de confirmation humaine.
🚀 Conseil pratique : avant d’évaluer l’adoption d’une architecture multi-agents, testez d’abord sur de petites tâches les performances des différents modèles dans chaque sous-rôle. Avec APIYI apiyi.com, une seule clé API permet d’appeler Gemini, Claude, GPT et d’autres modèles ; les nouveaux utilisateurs bénéficient d’un quota de test gratuit, ce qui est idéal pour valider rapidement la faisabilité d’une approche par couches.
Jugement 3 : l’avantage structurel de Google se situe au niveau du « full-stack », pas sur un point isolé
Si on regarde le modèle ou l’IDE isolément, Google n’est pas le seul choix. Mais il peut relier plusieurs maillons en une boucle fermée, ce qui est difficile à reproduire pour ses concurrents :
- Modèle Gemini développé en interne : il peut être optimisé en profondeur pour les scénarios d’agents, avec des coûts mieux maîtrisés
- Google Cloud : Vertex AI et Cloud Run couvrent toute la chaîne, de l’entraînement au déploiement en entreprise
- Écosystème Chrome / Web : les extensions de navigateur permettent aux agents de « voir » et d’« agir » sur les pages web, un avantage net dans les scénarios de test navigateur
- Plus de 40 000 utilisateurs internes : c’est un groupe de bêta-testeurs très large pour le codage agentique, avec une boucle de retour très courte
- Recherche et graphe de connaissances : les agents peuvent accéder à des informations en temps réel
- Gemini Spark : étend les capacités d’exécution d’Antigravity aux utilisateurs ordinaires
Passer de Gemini CLI à l’Antigravity CLI propriétaire, on peut le lire comme Google qui déblaie le terrain pour une intégration full-stack. Un CLI open source convient bien aux expérimentations communautaires, mais il peut difficilement porter un couplage profond avec Cloud, Chrome, des modèles sur mesure, et la commercialisation qui va avec. C’est une inférence basée sur les faits ; les annonces officielles de Google restent formulées autour d’une « transition et mise à niveau ».
Jugement n°4 : la véritable portée du cas Linus tient à la « production interdomaines »
Le cas de Linus est souvent lu comme une simple caution offerte par une figure de proue. Ce qui mérite davantage attention, c’est le contexte dans lequel il s’en est servi : recourir à une langue qu’il ne maîtrise pas pour fabriquer un outil d’appoint dans un domaine qui n’est pas le sien. La formule « supprimer l’intermédiaire — à savoir moi-même » décrit précisément la bascule de l’agent, d’« assistant » à « autonome ».
Pour le développeur ordinaire, la leçon à en tirer est que le gain marginal le plus fort d’un outil agentique n’apparaît pas forcément dans votre domaine principal, mais plutôt sur les tâches périphériques où vous « comprenez le besoin sans maîtriser l’implémentation ». Cela dit, Linus lui-même possède un jugement redoutablement affûté, capable d’évaluer si le résultat est exploitable. Ce préalable n’est pas donné à tous les utilisateurs.
Jugement n°5 : la liste des risques fixe le plafond d’Antigravity
En misant sur Antigravity, Google s’expose à quatre catégories de risques dont nous estimons l’impact inégal :
- Failles de sécurité (impact le plus direct) : l’injection de prompts et les fuites de données ont déjà fait l’objet d’analyses publiques. Plus les permissions accordées à l’agent sont larges, plus la surface d’attaque s’étend. La conception des Policies et du HITL permet de réduire les risques, mais pas de les éliminer.
- Cœur en source fermée (impact sur la confiance) : le passage de Gemini CLI de l’open source au closed source pourrait pousser une partie des développeurs de la communauté open source à attendre de voir, et les équipes de sécurité des entreprises auront plus de mal à auditer son comportement.
- Verrouillage de l’écosystème (impact sur les achats des entreprises) : une fois couplé étroitement à Google Cloud, la compatibilité avec AWS et Azure deviendra un point de vigilance pour les entreprises multi-cloud.
- Fragmentation produit (impact sur le coût de prise en main) : cinq lignes de produits — App, IDE, CLI, SDK, Extensions — avancent en parallèle, la courbe d’apprentissage est raide et un nouvel utilisateur a bien du mal à savoir par où commencer.
Ce qui suit relève de la prédiction : dans les temps à venir, la capacité d’Antigravity à passer de « pratique en interne chez Google » à « premier choix des développeurs externes » pourrait bien ne pas dépendre des indicateurs de performance de Swarm, mais de la réponse plus convaincante que Google saura apporter sur le terrain de la sécurité et de l’ouverture.
Comment les développeurs peuvent s’adapter aux changements apportés par Antigravity
Pour les développeurs et les équipes qui évaluent des outils de codage agentiques, voici quelques pratiques à considérer :
- Faire de la capacité de revue une compétence clé : plus les agents produisent, plus les humains doivent juger « si ce code est fiable ». La revue des artefacts (Artifact Review) ne doit pas devenir une simple formalité.
- Commencer par le moindre privilège : en s’inspirant des politiques déclaratives, interdire par défaut l’exécution de commandes, puis les autoriser progressivement selon les besoins.
- Éviter la dépendance à un fournisseur unique : découpler la logique d’orchestration du modèle concret et conserver la possibilité de passer aux modèles d’autres fournisseurs. Avec une interface d’agrégation compatible OpenAI comme APIYI apiyi.com, il suffit de changer le nom du modèle pour basculer, ce qui réduit le risque de verrouillage.
- Commencer par des tâches décomposables : tester d’abord le mode Swarm sur des tâches faiblement couplées comme la génération de tests, la complétion de documentation ou les outils de script, avant d’élargir progressivement le périmètre.
Si votre équipe n’envisage pas encore de migrer vers Antigravity, mais souhaite d’abord acquérir de l’expérience via la collaboration multi-modèles, vous pouvez utiliser les exemples précédents pour monter un petit prototype sur APIYI apiyi.com. La plateforme facture à l’usage, ce qui convient pour maîtriser les coûts pendant la phase d’évaluation.
Le pari de Google consiste, au fond, à répondre à une question : lorsque l’entité qui écrit le code passe de l’humain à un ensemble d’agents, qui définit les règles d’orchestration, les limites de permissions et le processus de revue ? Antigravity apporte la réponse de Google, et la question de savoir si cette réponse deviendra un standard du secteur dépendra de ses performances à venir en matière de sécurité, d’ouverture et de facilité d’utilisation.
Références
- xkcd 353 : le comic correspondant à l’easter egg
import antigravity- Lien :
xkcd.com/353
- Lien :
- Blog des développeurs Google : annonce officielle de la migration de Gemini CLI vers Antigravity CLI
- Lien :
developers.googleblog.com/an-important-update-transitioning-gemini-cli-to-antigravity-cli
- Lien :
- README d’AudioNoise de Linus Torvalds : texte d’origine de l’utilisation d’Antigravity
- Lien :
github.com/torvalds/AudioNoise
- Lien :
- Blog de Simon Willison : reportage sur le cas de Linus Torvalds
- Lien :
simonwillison.net/2026/Jan/11/linus-torvalds
- Lien :
- Blog de Simon Willison : analyse de sécurité sur l’exfiltration de données de Google Antigravity
- Lien :
simonwillison.net/2025/Nov/25/google-antigravity-exfiltrates-data
- Lien :
- Blog de Simon Willison : reportage sur Google I/O 2026
- Lien :
simonwillison.net/2026/May/20/google-io
- Lien :
Auteur : équipe technique APIYI
Échanges techniques : n’hésitez pas à visiter la page d’accueil d’APIYI apiyi.com pour nous contacter ; pour plus de documentation sur l’intégration multi-modèles, consultez le centre de documentation docs.apiyi.com.