La plupart des bibliothèques d'agents naissent en Python et y restent. Une équipe qui travaille en Java ou en TypeScript choisit alors entre un service séparé dans un autre langage et tout écrire à partir de zéro.
Google ADK est livré en parallèle dans cinq langages : Python, TypeScript, Go, Java et Kotlin, avec le même modèle conceptuel dans chacun. Les quatre premiers ont des versions stables ; celle de Kotlin est la plus jeune et reste avant la version 1.0. Le framework est open source, et son foyer de déploiement naturel est l'infrastructure de Google, sans pourtant y être lié.
Le modèle conceptuel
Un agent est un modèle avec des instructions et un ensemble d'outils. Rien de surprenant, et c'est ainsi que fonctionne chaque bibliothèque de cette catégorie.
pip install google-adkfrom google.adk.agents import Agent
def check_status(number: str) -> dict:
"""Returns the status of the order with the given number.
Call this when a customer asks about their order.
"""
return {"status": db.status(number)}
agent = Agent(
name="support",
model="gemini-2.5-flash",
instruction="You answer questions about orders. No preamble.",
tools=[check_status],
)Un outil est une fonction ordinaire dont le schéma vient des annotations de type et de la docstring. Une phrase qui dit quand appeler la fonction améliore la précision plus qu'une modification de l'instruction système, et cela vaut pour toutes les bibliothèques d'agents.
Cela devient plus intéressant à la composition. Un agent peut contenir des sous-agents auxquels il délègue, et le framework fournit des patterns de flux : exécution séquentielle, exécution parallèle et boucle jusqu'à ce qu'une condition soit remplie.
Sous-agents et flux
C'est la principale différence avec les bibliothèques où tout se réduit à un seul agent avec une liste d'outils.
from google.adk.agents import SequentialAgent, ParallelAgent
gathering = ParallelAgent(
name="gathering",
sub_agents=[docs_agent, issues_agent, code_agent],
)
flow = SequentialAgent(
name="analysis",
sub_agents=[gathering, synthesis_agent],
)L'exécution parallèle a ici un but concret. Trois recherches indépendantes menées ensemble prennent le temps de la plus longue et non la somme de leurs durées. Sur des tâches qui couvrent plusieurs sources, la différence se remarque.
L'exécution séquentielle décrit des étapes où un résultat alimente le suivant. L'exécution en boucle répète une étape jusqu'à ce qu'une condition soit remplie, ce qui convient pour affiner un résultat jusqu'à ce qu'il satisfasse.
Attention cependant à ne pas en faire trop. Cinq agents qui se passent une tâche forment un système que personne ne suivra, et diagnostiquer une mauvaise réponse revient à parcourir cinq traces. Trois rôles suffisent pour la plupart des applications.
Le protocole d'échange entre agents
Le framework prend nativement en charge un protocole qui permet à des agents de plateformes différentes de dialoguer. Il répond à un problème que rencontrent les grandes organisations.
La situation est la suivante : une équipe a construit un agent dans ce framework, une autre dans LangGraph, une troisième dans l'outil d'un fournisseur cloud. Sans protocole commun, les relier signifie écrire des adaptateurs pour chaque paire.
Le protocole définit comment un agent annonce ses capacités et comment il accepte des tâches venant d'autres agents. Un agent distant ressemble alors, pour votre agent, à un outil ordinaire, quel que soit le langage dans lequel il a été écrit.
Distinguez-le du protocole d'exposition d'outils décrit dans l'article sur MCP. Ce dernier relie un agent à des outils ; le premier relie des agents entre eux. Les deux apparaissent dans un même système et ne s'excluent pas.
Au sein d'une seule équipe, le mécanisme est superflu. Il justifie sa place quand des parties d'un système sont construites indépendamment et que personne ne les contrôle toutes.
État de session et mémoire
Un agent qui répond à des questions isolées n'a besoin de rien de plus que son entrée. Un agent qui tient une conversation doit se souvenir de ce qui a été dit, et un agent qui exécute une tâche en plusieurs étapes doit stocker des résultats intermédiaires.
Le framework les sépare en trois niveaux qu'il vaut la peine de distinguer. L'état de session contient la conversation en cours. L'état utilisateur contient des éléments durables, par exemple des préférences. L'état d'application couvre toutes les sessions et contient la configuration partagée.
from google.adk.sessions import InMemorySessionService
sessions = InMemorySessionService()
session = await sessions.create_session(app_name="support", user_id="customer-118")La variante en mémoire convient aux tests et disparaît avec le processus. La production demande un service durable, disponible dans l'environnement managé ou construit par vous au-dessus d'une base de données.
Réfléchissez à ce qui relève de l'état et à ce qui relève de la base de données de l'application. L'état de session est pratique et tentant, si bien que des choses qui devraient vivre dans un modèle de données normal s'y retrouvent. La règle est simple : l'état contient ce qui concerne le déroulement de la conversation, et la base de données contient ce qui est un fait sur le client, qu'une conversation soit en cours ou non.
Callbacks et contrôle du flux
Le framework permet d'attacher votre propre code avant un appel au modèle, avant un appel d'outil et après chacun. C'est l'équivalent des middlewares bien connus des serveurs et il sert aux mêmes fins.
Trois usages reviennent le plus. Le premier, ce sont les limites de coût, où un callback arrête le travail au-delà d'un seuil. Le deuxième, c'est l'approbation d'actions irréversibles, où le code met l'appel d'outil en pause et demande un consentement. Le troisième, c'est le filtrage des entrées, c'est-à-dire rejeter les requêtes hors périmètre avant que le modèle plus coûteux ne s'exécute.
Ce dernier pattern mérite l'attention pour des raisons économiques. Une vérification peu coûteuse avec un modèle léger rejette les requêtes hors sujet avant que l'agent ayant accès aux outils ne démarre. Vous économisez des tokens et réduisez la surface où les choses peuvent mal tourner.
Rappelez-vous qu'un callback basé sur un modèle n'est pas une protection au sens de la sécurité des systèmes. Il protège contre les comportements déviants typiques et non contre une attaque délibérée, donc continuez à imposer les permissions dans le code des outils.
Traces et évaluation
Le framework collecte un enregistrement de chaque exécution : appels au modèle, appels d'outils, passages de relais entre agents. Cela fonctionne en local dans l'outil d'inspection et dans l'environnement cloud après le déploiement.
Diagnostiquer un agent sans trace revient à deviner pourquoi il a fait quelque chose d'étrange. Avec une trace, vous voyez exactement quel outil il a appelé, avec quels arguments et ce qui est revenu. C'est le même principe qu'avec LangSmith et d'autres outils d'observabilité.
En plus des traces, il existe un mécanisme d'évaluation sur un jeu de cas. Vous définissez des questions avec des résultats attendus et vous les lancez après chaque modification des instructions pour détecter une régression.
Trente cas suffisent pour voir la différence entre des variantes. Collectez-les à partir du trafic réel, surtout dans les situations où l'agent a échoué, car ce sont celles qui reviennent le plus. Un jeu construit à partir de cas faciles réussit à chaque fois et ne dit rien sur l'effet d'un changement.
Déploiement
Un agent écrit dans ce framework est un programme ordinaire, donc il tourne là où tourne tout le reste : dans un conteneur, dans une fonction serverless, sur votre propre serveur.
La voie recommandée par le fournisseur est un environnement managé dans son cloud, conçu pour exécuter des agents. Il vous décharge de la mise à l'échelle, de la tenue des sessions et de la collecte des traces, au prix d'un attachement à une seule plateforme.
Séparez cette décision du choix du framework. Le framework lui-même est open source et n'exige pas ce cloud, donc vous pouvez écrire un agent avec lui et le déployer ailleurs. Le confort de l'environnement managé est réel et il n'est pas obligatoire.
La troisième voie est un déploiement dans un conteneur chez n'importe quel fournisseur. Vous perdez la gestion de sessions toute prête et vous gagnez l'indépendance ainsi que la possibilité de garder les données là où les règles l'exigent. Les sessions doivent alors reposer sur votre propre base de données, ce qui, avec un backend existant, se résume en général à une table plutôt qu'à un projet séparé.
Outils prêts à l'emploi et personnalisés
Au-delà de vos propres fonctions, le framework fournit des outils intégrés et des moyens de connecter des outils qui vivent ailleurs.
Les outils intégrés couvrent la recherche web et l'exécution de code dans un sandbox. Les deux s'exécutent côté fournisseur, donc vous n'avez pas à les héberger, au prix d'une partie du traitement qui se déroule hors de votre infrastructure.
La deuxième voie connecte des serveurs qui exposent des outils via un protocole commun. Des intégrations prêtes à l'emploi, avec un dépôt de code ou un gestionnaire de tickets par exemple, se branchent alors sans écrire vos propres adaptateurs.
La troisième est d'utiliser des outils d'autres bibliothèques d'agents. Le framework peut envelopper un outil écrit pour une autre bibliothèque, ce qui aide pendant une migration ou quand l'intégration dont vous avez besoin n'existe que là.
L'ordre pratique va à l'encontre de l'intuition. Vérifiez d'abord si l'outil existe déjà à l'un de ces trois endroits. Écrire votre propre adaptateur autour d'une interface de programmation que quelqu'un a déjà enveloppée, c'est faire le travail deux fois, avec la maintenance à votre charge.
Attention au nombre, cependant. Chaque outil connecté occupe de la place dans le contexte et diminue la précision de sélection, donc brancher tout ce qui est disponible dégrade le résultat au lieu de l'améliorer.
ADK face aux alternatives
| Option | Point fort | Point faible | À choisir quand |
|---|---|---|---|
| Google ADK | Cinq langages, patterns de flux, protocole d'échange | Mieux adapté à un seul cloud | Équipe hors Python, déploiement chez ce fournisseur |
| OpenAI Agents SDK | Peu de concepts, traces sans configuration | Orienté vers un seul fournisseur | Une équipe de rôles qui se passent une conversation |
| LangGraph | Contrôle total du flux, état durable | Plus de travail sur les cas simples | Processus avec embranchements et pauses |
| PydanticAI | Sortie typée, tests sans modèle | Python uniquement | Résultat qui alimente directement le code |
Pour une équipe qui travaille en Java ou en Go, la première ligne est souvent le seul choix raisonnable, car les alternatives imposeraient un service Python séparé. C'est un argument réel, invisible dans les comparatifs centrés sur les capacités.
Pour une équipe Python, le choix est plus large et mérite d'être comparé entre plusieurs bibliothèques sur votre propre tâche. Les différences portent sur le confort et l'écosystème, car toutes reposent sur le même mécanisme d'appel d'outils que les fournisseurs de modèles exposent.
C'est le bon moment pour nommer ce qui se perd dans les comparatifs de bibliothèques. La qualité d'un agent se joue sur les descriptions des outils, les limites fixées dans l'instruction et le jeu de cas sur lequel vous mesurez les changements. Ces trois éléments passent d'une bibliothèque à l'autre presque inchangés, donc le travail qui y est investi ne se perd pas lors d'une migration.
Le choix du framework influence autre chose : la facilité avec laquelle un agent s'insère dans un système existant et à quoi ressemble le déploiement. Pour une équipe qui travaille en Java et déploie chez ce fournisseur, la différence se voit dès le premier jour, et pour une équipe Python avec sa propre infrastructure, elle est nettement plus petite.
Erreurs courantes
La première, ce sont des descriptions d'outils écrites pour un développeur. Le modèle lit le même texte et a besoin d'une phrase sur le moment où appeler la fonction, pas d'une description de l'implémentation.
La deuxième, ce sont trop de sous-agents. Cinq niveaux d'imbrication donnent un système où diagnostiquer une mauvaise réponse revient à parcourir chaque trace tour à tour.
La troisième, c'est l'absence de plafond d'étapes. Un agent qui appelle des outils en boucle brûle autant de tokens que vous l'autorisez, et sur un modèle haut de gamme cela devient cher.
La quatrième, c'est de passer un identifiant d'utilisateur dans les arguments des outils. Le modèle peut fournir celui de quelqu'un d'autre, donc l'identité doit venir du contexte d'exécution.
La cinquième, c'est de déployer sans jeu de cas. Une modification d'instruction qui améliore une conversation en casse généralement une autre, et sans jeu personne ne s'en aperçoit.
La sixième, c'est de recourir au protocole d'échange entre agents au sein d'une seule équipe. Il résout la collaboration entre équipes indépendantes et, sur une seule base de code, ajoute de la complexité sans bénéfice.
FAQ
Quels langages ADK prend-il en charge ?
Python, TypeScript, Go, Java et Kotlin, avec le même modèle conceptuel dans chacun et un jeu de pages de documentation séparé pour chacun. C'est sa principale distinction par rapport aux bibliothèques disponibles uniquement en Python, car elle permet à une équipe de travailler dans le langage que le reste du système utilise déjà. Vérifiez simplement le numéro de version de la variante choisie, car celle de Kotlin est arrivée en dernier et reste avant la version 1.0.
ADK exige-t-il le cloud de Google ?
Non, le framework est open source et un agent tourne dans un conteneur ou une fonction serverless chez n'importe quel fournisseur. L'environnement managé du fournisseur simplifie la mise à l'échelle et la collecte des traces, mais c'est un choix et non une condition.
En quoi le protocole A2A diffère-t-il de MCP ?
Le protocole décrit dans l'article sur MCP relie un agent à des outils et à des sources de données. Le protocole d'échange entre agents relie des agents entre eux, y compris ceux écrits dans d'autres frameworks. Les deux apparaissent dans un même système.
Fonctionne-t-il avec d'autres modèles que Gemini ?
Oui, la couche modèle prend en charge plusieurs fournisseurs, même si l'intégration avec les modèles de ce fournisseur est la plus poussée. Pour comparer, passez vos propres cas dans plusieurs modèles, car les différences dépendent davantage de la tâche que des benchmarks.
Quand faut-il choisir autre chose ?
Quand vous travaillez en Python et voulez une sortie typée ou des tests sans appeler de modèle, car il existe pour cela des bibliothèques mieux adaptées. Quand vous avez besoin d'un contrôle total d'un flux avec des pauses pour des décisions humaines, une solution à base de graphe est la bonne direction.
La documentation se trouve sur le site du projet, et la prise en charge du protocole d'échange dans un chapitre séparé.