Comparaison des agents gérés : Anthropic, LangGraph et Google ADK
Qui gère le sandbox, les identifiants et les traces ? Une comparaison des Anthropic Managed Agents, LangGraph et Google ADK en ce qui concerne les prix, les modes de défaillance et un guide de décision rapide.
Sources: Anthropic Managed Agents vs LangGraph vs Google ADK: Pick One
Image de 3 h du matin. Une erreur apparaît dans Sentry. Un bot lit le rapport d’erreur, l’attribue à une condition de concurrence dans le code des paiements, écrit la correction correspondante et ouvre une demande de fusion. Lorsque l’ingénieur de garde ouvre Slack à 7 heures, une demande de fusion est déjà là, prête à être examinée. Personne n’a écrit la différence de code ni soumis de ticket.
Ce bot est un agent géré. Auparavant, créer un tel agent nécessitait six ingénieurs et un quart d’année de travail : un environnement de test sur mesure, un stockage d’état, une logique de tentative répétée, un coffre-fort pour les identifiants et un pipeline d’audit. Sentry a développé le sien avec une équipe en six semaines, et la différence ne réside pas dans un modèle plus intelligent. Désormais, quelqu’un d’autre s’occupe des aspects techniques. Cet agent prend l’analyse de la cause racine fournie par Seer, l’intelligence artificielle diagnostique de Sentry, et la transforme en une demande de fusion contenant la correction. Anthropic l’a désigné comme premier client le 10 avril 2026.
Trois fournisseurs vendent désormais ce service à grande échelle : Anthropic, LangChain et Google. Leurs stratégies diffèrent quant à la répartition des tâches opérationnelles entre vous et eux. Ce qui suit décrit ce qui a changé, ce que chacun propose, où chacun a tendance à échouer et comment faire son choix. La vraie question n’est pas de savoir quel framework est le meilleur, mais plutôt quelle interface opérationnelle votre équipe souhaite maîtriser.
Que signifie « agent géré »
Commençons par le mot « agent ». Il s’agit d’un logiciel qui reçoit une tâche, choisit des actions, utilise des outils, vérifie l’avancement et recommence le processus. Un chatbot n’est pas cela.
« Géré » signifie que le fournisseur gère l’infrastructure : le conteneur sécurisé, l’état de la session, les identifiants, ainsi que les tentatives de réessai en cas de problème réseau. Vous fournissez la tâche et les définitions des outils. Les agents gérés correspondent au code d’agent développé manuellement, de la même manière que les bases de données gérées correspondent à Postgres hébergé localement. Vous conservez le schéma et les requêtes, tandis que le fournisseur s’occupe du matériel, des sauvegardes, de la bascule en cas de panne et du suivi.
C’est ainsi que cela fonctionne. Vous soumettez une tâche, par exemple « résumer ces trois articles en un rapport d’une page ». Le prestataire lance alors un conteneur Linux sécurisé, et l’agent commence à travailler à l’intérieur, en appelant des outils et en écrivant des fichiers, tandis que les résultats vous sont renvoyés. Même si vous fermez votre ordinateur portable, le processus continue. Même en cas de perte de connexion réseau, il fonctionne toujours. Lorsque vous vous reconnectez une heure plus tard, vous reprenez le travail là où vous l’aviez laissé. Chaque action est enregistrée dans un journal de session fiable, à l’instar d’un historique de commits ou d’un livre de comptes, et ce journal constitue la source de vérité.
C’est là le changement fondamental. L’agent n’existe plus à l’intérieur de votre processus ; il s’agit d’un travailleur côté serveur qui survit aux interruptions de connexion, aux redémarrages et au mode veille des ordinateurs portables. Vous n’avez pas besoin d’écrire de code pour obtenir ce comportement. Il n’y a encore aucun code impliqué. Vous définissez la tâche, le fournisseur gère l’agent, et le résultat perdure indépendamment de votre connexion.
Pourquoi c’est crucial maintenant
La plupart des agents d’entreprise échouent dès la phase de démonstration. Le notebook s’exécute, la vidéo est de qualité, mais ensuite, en environnement de production, on exige des fonctionnalités que personne ne veut développer. Il faut un environnement isolé pour que l’agent ne puisse pas toucher l’hôte, un coffre-fort pour éviter que les tokens ne fuient, une capacité de persistance afin qu’un redéploiement ne mette pas fin à une exécution en cours, des tentatives de réessai en cas de timeout des appels aux outils, une capacité d’observation permettant à la personne de garde de comprendre ce qui s’est passé à 2 heures du matin, ainsi que des alertes budgétaires pour éviter qu’un boucle infinie ne coûte 500 dollars avant que quiconque ne s’en aperçoive.
Rien de tout cela ne relève du travail sur les modèles. Il s’agit entièrement de travail sur la plateforme, or la plupart des équipes d’IA ne disposent pas d’ingénieurs en plateforme en surplus.
La proposition d’Anthropic vise justement ce manque. Les documents de lancement prévus pour avril 2026 promettent « une production 10 fois plus rapide ». Il s’agit d’une affirmation marketing et non d’une mesure concrète, mais elle cible bien le problème. Selon des rapports de presse (VentureBeat, donc pas un chiffre divulgué par Anthropic), le revenu annuel récurrent de l’entreprise dépasse les 30 milliards de dollars, dont environ 80 % proviennent du secteur des entreprises. Le produit Managed Agents permet de résoudre le problème qui bloquait la génération de ces revenus.
Quatre clients pilotes ont déjà mis le produit en service. Notion intègre des agents spécialisés dans l’ingénierie et le travail intellectuel dans son espace de travail. Rakuten utilise ces agents pour gérer les produits, les ventes, le marketing et les finances. Sentry distribue son bot de relations publiques. Asana l’a employé pour accélérer le développement d’AI Teammates.
Un aperçu des trois plateformes
Ils diffèrent quant à la part de travail assurée par le fournisseur et celle que vous effectuez. La solution d’Anthropic étant la plus récente, elle fait l’objet de la description la plus détaillée ci-dessous. LangGraph et Google ADK existent déjà depuis un certain temps.
Agents gérés par Anthropic
Lancé le 10 avril 2026, il s’agit du premier produit d’agent entièrement géré par un fournisseur de modèles. Anthropic gère le conteneur d’exécution, le stockage de l’historique des sessions, le coffre-fort des identifiants, la logique de tentative pour les appels d’outils échoués ainsi que le suivi des opérations. Vous devez uniquement définir deux éléments : la description de la tâche et la liste des outils.
Une seule exécution se déroule comme suit : vous envoyez une requête POST indiquant "démarrer un agent avec ces outils pour cette tâche". Anthropic lance alors un conteneur Linux temporaire, c’est-à-dire qu’il est créé au début et détruit à la fin, de sorte que les sessions ne partagent jamais de système de fichiers. Claude exécute la boucle suivante : lire la tâche, choisir une étape, appeler un outil, lire le résultat, puis décider à nouveau. Chaque événement est enregistré dans un journal de session que Anthropic conserve pour vous, sous forme de registre d’écriture uniquement. Les événements vous sont renvoyés via HTTP, et si votre connexion est interrompue, l’agent continue de fonctionner.
Les tarifs sont inhabituels pour un service d’infrastructure. Vous payez les taux normaux des tokens Claude plus huit cents fixes par heure de session active. Un bot fonctionnant 24 heures sur 24 coûte environ 58 dollars par mois en temps de fonctionnement, sans compter les tokens, tandis qu’un exécution de trois minutes pour traiter un ticket de support coûte moins d’un centime. La facturation se fait en fonction du temps écoulé pendant la session, et non en fonction du temps d’utilisation du CPU.
Le prix de cette commodité réside dans le couplage. Le temps de fonctionnement est conçu pour Claude, ce qui vous empêche d’intégrer un modèle différent sans réécrire la couche de raisonnement. La solution consiste à utiliser le SDK Claude Agent open source, qui propose un même mécanisme d’agent sous forme de bibliothèque que vous hébergez vous-même. En échange, vous obtenez un environnement de fonctionnement que quatre entreprises ont mis en production moins de six semaines après son lancement. LangChain et Google proposent des plateformes d’agents depuis environ dix-huit mois, donc la nouveauté ici réside dans un environnement de fonctionnement entièrement géré par un fournisseur de modèles.
LangGraph avec LangSmith
Cette paire correspond au plan de contrôle, un outil qui s’installe sur votre infrastructure et coordonne le fonctionnement de l’agent. Vous créez le graphe, un organigramme des étapes que suit l’agent. LangChain fournit l’hébergement, le suivi (un enregistrement de chaque étape) ainsi qu’un stockage des traces, la base de données où ces enregistrements sont conservés et peuvent être recherchés. La bibliothèque de graphes est sous licence MIT, ce qui vous permet de la copier, de la modifier ou de l’héberger vous-même librement, ce qui assure une véritable portabilité. Le verrouillage réside dans le stockage des traces, car celles-ci ne peuvent être recherchées en totalité qu’à l’intérieur de LangSmith.
Google ADK avec Vertex AI Agent Engine
Cette approche suppose que vous utilisez déjà Google Cloud. Vous écrivez des agents en Python (Java et TypeScript arriveront d’ici 2026) et les déployez dans Agent Engine, l’environnement d’exécution géré par Google sur Cloud Run ou Kubernetes. L’agent hérite de votre politique de sécurité cloud : règles de périmètre réseau, politiques de clés de chiffrement et configuration IAM. Lorsque vos documents de conformité mentionnent déjà Google Cloud, ADK représente le chemin le plus rapide pour passer d’un prototype à une solution approuvée par votre équipe de sécurité.
Ce que propose Anthropic Managed Agents
Vous décrivez la tâche et Anthropic s’en charge. Le code montre à quel point il est peu nécessaire d’écrire du code :
import os
import httpx
from anthropic import Anthropic, APIStatusError
# API surface is beta (managed-agents-2026-04-01); confirm against
# platform.claude.com/docs before shipping.
client = Anthropic(
api_key=os.environ["ANTHROPIC_API_KEY"],
default_headers={"anthropic-beta": "managed-agents-2026-04-01"},
)
# The Managed Agents surface uses two REST endpoints against the beta:
# POST /v1/managed-agents/sessions -> create a session
# POST /v1/managed-agents/sessions/{id}/runs -> start a run on that session
# Use httpx directly until the typed namespace stabilizes in the SDK.
BASE = "https://api.anthropic.com/v1/managed-agents"
session = client.post(
f"{BASE}/sessions",
json={
"model": "claude-opus-4-7",
"tools": ["bash", "code_execution", "web_fetch", "memory"],
"sandbox": {"network": "egress_allowlist", "timeout_hours": 24},
"system": (
"You are a research summarizer. Fetch the top three papers "
"on retrieval-augmented generation from arXiv this week, "
"run eval code, and write a one-page brief."
),
},
).json()
run = client.post(
f"{BASE}/sessions/{session['id']}/runs",
json={"input": "Start the weekly research brief."},
).json()
# Stream run events; wrap to survive transient disconnects.
try:
with client.stream("GET", f"{BASE}/runs/{run['id']}/events") as events:
for event in events.iter_lines():
print(event)
except (httpx.RemoteProtocolError, APIStatusError) as e:
# Persist run['id'] and reattach with GET /runs/{id}/events; the
# session log survives disconnects so the agent is not lost.
raise
C’est un agent de production décrit en quelques dizaines de lignes. Il n’y a pas de manifest Kubernetes, aucune image de sandbox à gérer, ni configuration de checkpointer. L’en-tête managed-agents-2026-04-01 vous inscrit dans ce que les ingénieurs d’Anthropic décrivent comme un méta-harness, composé de trois éléments distincts.
La session représente un journal d’écriture uniquement. Les appels aux outils, les messages de l’agent ainsi que ses observations y sont tous enregistrés, formant un fichier durable que l’on peut rejouer du début à la fin. Le méta-harness comprend Claude ainsi que les interfaces des outils, le cycle qui lit la session, choisit l’action suivante, appelle l’outil et enregistre le résultat. La sandbox est un conteneur Linux éphémère, créé pour chaque tâche et supprimé à son terme. Les identifiants Git et les tokens MCP OAuth sont stockés dans des coffres-forts situés en dehors de la sandbox, permettant ainsi à l’agent d’y accéder sans jamais les conserver en mémoire.
La persistance de la session est une fonctionnalité souvent sous-estimée. Une tâche de recherche qui dure plusieurs heures ne se réinitialise pas lorsque le client se déconnecte. La session reste en place, l’agent se reconnecte automatiquement et continue son travail. Toute personne ayant supervisé une tâche longue via un réseau Wi-Fi instable appréciera cela.
En termes de coûts, le montant mensuel de 58 dollars pour un agent disponible 24/7 paraît moins élevé comparé à six semaines de travail dans un environnement de test personnalisé. En ce qui concerne les preuves concrètes, Notion intègre des agents techniques aux côtés des agents dédiés aux travailleurs du savoir, Rakuten relie des agents à Slack et Teams au sein de plusieurs départements pour récupérer des tableurs, des diapositives et des applications, l’agent de Sentry rédige la correction et ouvre une demande de modification, et Asana attribue à cette plateforme le mérite d’avoir permis à l’équipe de se concentrer sur l’expérience utilisateur multijoueur plutôt que sur les aspects techniques en temps de exécution.
Le verrouillage est réel : vous ne pouvez pas remplacer Gemini ou GPT d’un seul coup sans quitter le système. La solution de sortie est le Claude Agent SDK, qui peut fonctionner sur AWS Bedrock, Google Vertex AI ou Azure AI Foundry. Si votre logique est écrite en fonction des interfaces du SDK dès le début, quitter l’environnement géré constitue un simple changement de déploiement, et non une réécriture complète.
Ce que propose LangGraph
LangGraph vous fournit les composants, c’est à vous de les assembler.
import os
from langgraph.graph import StateGraph, START, END
from langgraph.checkpoint.postgres import PostgresSaver
from typing import TypedDict
class State(TypedDict):
query: str
sources: list
draft: str
approved: bool
def fetch_sources(state: State) -> State:
# implement with your retrieval and LLM layer
return {"sources": retrieve(state["query"])}
def draft_answer(state: State) -> State:
# implement with your retrieval and LLM layer
return {"draft": synthesize(state["sources"])}
def human_review(state: State) -> State:
# interrupt; resumes when approval is posted
return state
graph = StateGraph(State)
graph.add_node("fetch", fetch_sources)
graph.add_node("draft", draft_answer)
graph.add_node("review", human_review)
graph.add_edge(START, "fetch")
graph.add_edge("fetch", "draft")
graph.add_edge("draft", "review")
graph.add_conditional_edges(
"review",
lambda s: "done" if s["approved"] else "draft",
{"done": END, "draft": "draft"},
)
# Never hardcode DSN - pull from env and configure a connection pool in prod.
DSN = os.environ["POSTGRES_DSN"]
app = graph.compile(checkpointer=PostgresSaver.from_conn_string(DSN))
Pensez à LangGraph comme un éditeur de machines à états pour le comportement des agents. Le graphe définit l’étape suivante ainsi que les données transmises. Chaque nœud représente une fonction simple, chaque arête est déclarée explicitement, et chaque branche peut être auditée.
En octobre 2025, LangChain a renommé la plateforme LangGraph en LangSmith Deployment. LangSmith sert aujourd’hui plus de 300 clients entreprises et a traité plus de 15 milliards de traces ainsi que 100 billions de tokens. Ce volume constitue un avantage concurrentiel majeur, car l’engagement opérationnel réside dans les capacités d’observation et non dans la bibliothèque de graphes MIT.
Les clients insistent sur le besoin de contrôle. L’assistant de Klarna, basé sur LangGraph et LangSmith, sert 85 millions d’utilisateurs actifs et a réduit le temps de résolution de 80 %. L’équipe de la plateforme de développement d’Uber a créé Validator pour détecter les violations et AutoCover pour générer des tests, au service de 5 000 ingénieurs et permettant, selon les rapports, d’économiser 21 000 heures de travail des développeurs. L’agent de codage de Replit gère des workflows multi-agents avec approbation humaine pour les installations de paquets et la création de fichiers, tandis que LangChain a dû étendre sa capacité à traiter les traces pour gérer des séquences comptant des centaines d’étapes. LinkedIn (un recruteur basé sur l’IA) et AppFolio (un copilote pour la gestion immobilière, dont l’exactitude décisionnelle serait doublée) figurent dans l’index des études de cas de LangChain, mais il convient de consulter la page du client correspondant avant de les considérer comme résolus.
Un schéma se dégage : dès qu’un flux de travail comporte plus de trois branches ou un point d’approbation humaine, les équipes choisissent LangGraph, car des abstractions de haut niveau cachent les boucles, les branches, les points de contrôle et la persistance nécessaires aux agents complexes.
Les coûts diffèrent de ceux des environnements gérés. Il existe un niveau gratuit pour les développeurs avec des limites mesurées, et ces seuils varient, il convient donc de consulter la page des tarifs de LangChain. Peu importe l’endroit où il s’exécute (SaaS, hybride ou auto-hébergé), la facture liée à l’infrastructure revient à l’utilisateur. La gestion des identifiants peut différer entre le niveau SaaS et la configuration par défaut en auto-hébergement, il faut donc vérifier cela dans les documents destinés aux entreprises selon votre option. LangChain le formule clairement : les abstractions de haut niveau permettent de commencer rapidement, tandis que la flexibilité de bas niveau gère les requêtes de production variées ; la courbe d’apprentissage est plus raide, mais les équipes ne quittent pas ce système. Replit et Uber en sont la preuve.
Ce que Google ADK fournit
ADK propose des primitives de flux de travail bien définies ainsi qu’un niveau de conformité intégré. Vous écrivez des agents en code, les déployez dans Vertex AI Agent Engine et maintenez ainsi votre posture de sécurité.
from google.adk.agents import LlmAgent, SequentialAgent, ParallelAgent
from google.adk.tools import built_in_tools, VertexAISearchTool
search_agent = LlmAgent(
name="research",
model="gemini-2.5-pro",
instruction="Retrieve the top 3 papers on RAG from the last 7 days.",
# replace with your Vertex AI Search datastore resource path
tools=[VertexAISearchTool(datastore="projects/.../ragDatastore")],
)
analyze_agent = LlmAgent(
name="analyze",
model="gemini-2.5-pro",
instruction="Summarize findings and extract evaluation methodologies.",
)
# Mandatory: prevent thinking-loop cost bombs before you deploy.
# - In code, cap iterative work by wrapping retry-heavy steps in a
# LoopAgent with a small max_iterations.
# - In Cloud Console: Billing > Budgets & Alerts > set a project-level
# budget alert (e.g., $10/day) with notification channel configured.
pipeline = SequentialAgent(
name="weekly_brief",
sub_agents=[search_agent, analyze_agent],
)
# Deploy to Vertex AI Agent Engine with inherited VPC-SC + CMEK.
# Set billing budget alerts in Cloud Console before deploying to prod.
from vertexai import agent_engines
remote = agent_engines.create(
agent_engine=pipeline,
requirements=["google-adk", "google-cloud-aiplatform"],
display_name="weekly-research-brief",
)
Les primitives racontent l’histoire. SequentialAgent exécute les étapes dans l’ordre, ParallelAgent les exécute en parallèle et LoopAgent répète une étape jusqu’à ce que une condition soit remplie. La primitive de graphe sous-jacente permet des formes arbitraires, ce qui offre quatre architectures prêtes à l’emploi. La version Python est à 1.0.0 et prête pour le déploiement en production, Java est à 0.1.0, et une version TypeScript devrait être disponible d’ici 2026.
Le wedge n’est pas le cadre de travail. C’est ce que Agent Engine vous fournit lors du déploiement. Les VPC Service Controls, qui constituent la périphérie réseau de Google, déterminent qui peut accéder à quoi. Les clés de chiffrement gérées par le client vous permettent, et non à Google, de contrôler le chiffrement des données. L’identité de l’agent IAM fait du agent un sujet de sécurité disposant de ses propres liens de politique. Les traces d’audit proviennent de Cloud Trace et de Cloud Logging. ADK inclut également plus de 100 connecteurs prédéfinis (AlloyDB, BigQuery, NetApp, entre autres) et utilise le protocole Agent-to-Agent de Google pour assurer l’interopérabilité.
Lorsqu’il est inactif, son coût est faible. Agent Engine facture 0,00994 dollar par vCPU-heure et 0,0105 dollar par GiB-heure ; les jetons et les appels d’outils sont comptabilisés séparément, et il existe un plan gratuit. Une étude de benchmark menée par un tiers a montré que ADK avec Gemini démarre légèrement plus rapidement que LangChain avec Gemini. Il s’agit au mieux d’un indicateur directionnel, il convient donc d’évaluer soi-même sa charge de travail avant de la présenter lors d’une réunion.
Pourquoi l’héritage de VPC-SC est important
ADK ne dispose pas encore d’études de cas majeures à l’échelle de Klarna ou Uber. C’est un acteur plus récent sur le marché. Le programme GEAR de Google, offrant 35 crédits d’apprentissage mensuels ainsi qu’un parcours de certification, subventionne la formation aux outils ADK pour les entreprises, tout comme AWS subventionnait Well-Architected il y a une décennie ; les études de cas sont encore en cours d’élaboration.
Le point fort d’ADK aujourd’hui réside dans les limites de conformité. Une entreprise régulée qui dispose déjà de périmètres VPC-SC, de politiques CMEK et de principaux IAM définis obtient un agent ADK qui hérite de tout cela sans aucune configuration supplémentaire, ce qui vaut plus que n’importe quelle fonctionnalité de framework. Vous achetez ainsi une solution qui s’intègre parfaitement à votre architecture de sécurité existante. Pour les équipes ne rencontrant pas d’exigences VPC-SC, l’argument lié à la gouvernance s’affaiblit, et LangGraph ou les agents gérés permettent probablement d’accélérer encore davantage le processus.
La matrice de responsabilités
Avec ces trois plateformes présentées, voici la comparaison essentielle : qui est responsable de chaque surface opérationnelle en production. Considérez-la comme un tableau des personnes de garde. Deux lignes sont bien plus importantes que les autres, et de nombreuses équipes d’entreprise se trompent dans leur évaluation concernant ces deux lignes.
Sandboxing. En choisissant LangGraph, vous disposez d’un environnement sandbox à votre disposition. Vous créez l’image du conteneur, configurez les connexions réseau sortantes, déterminez où le système de fichiers est éphémère et mettez à jour les correctifs CVE. Anthropic et Google offrent cette fonctionnalité par défaut. Si votre liste de tâches en attente est déjà élevée depuis quatre trimestres, le sandboxing en tant que service permet de gagner un trimestre supplémentaire.
Credentials. Managed Agents stocke les tokens Git et les tokens MCP OAuth dans des coffres-forts hors de l’environnement sandbox. Google ADK utilise l’identité d’agent IAM, ce qui fait de l’agent un acteur disposant de ses propres politiques. LangGraph laisse la gestion des identifiants à votre propre déploiement, bien que le niveau SaaS de LangSmith Deployment inclue une gestion gérée ; vous devez vérifier les détails dans votre contrat.
Cette dernière considération concerne l’impact potentiel. Si l’agent accède aux bases de données en production et que votre modèle repose sur un seul secret partagé, LangGraph ne vous offre aucune protection efficace en cas de défaillance.
Le coût en temps de exécution est moins important que l’un ou l’autre des autres facteurs. Le coût lié à l’observabilité devient très important avec le temps, car c’est grâce au relevé des traces généré par LangSmith que le coût total de LangGraph passe d’être prévisible à être surprenant.
Où chacune d’elles échoue
Chaque plateforme présente sa propre manière caractéristique d’échouer en production. Les exemples ci-dessous proviennent de la documentation des fournisseurs ou de professionnels qui les ont mises en œuvre.
Anthropic : compactage. C’est le moment où l’agent réduit l’historique de la session pour respecter la limite de contexte du modèle. Le blog technique d’Anthropic indique clairement que le compactage entraîne des décisions irréversibles quant aux éléments à conserver, et souligne qu’il est difficile de savoir quels tokens seront nécessaires pour les prochaines étapes. En pratique, cela peut entraîner la perte de contextes dont l’agent aura besoin par la suite, ce qui fait échouer l’exécution. Le premier test dans toute évaluation consiste en une tâche nécessitant des informations provenant des 20 % premiers d’une session après les 80 %. Si celle-ci échoue silencieusement, vous avez alors identifié les limites de la plateforme.
Google ADK : le cycle de réflexion. Un rapport de terrain de Composio décrit une facturation de 5 dollars liée à une session bloquée, où un agent continuait d’appeler un outil défaillant, en essayant à nouveau sans cesse, gaspillant des minutes de ressources vCPU tandis que les jetons s’accumulaient. Selon le rapport de l’ingénieur de Composio, les démonstrations semblaient excellentes, mais la version en production échouait à la plupart des appels aux outils et entraînait des coûts de 5 dollars dus à ces appels répétés. Composio a un intérêt commercial dans la comparaison avec ADK, il convient donc de le considérer comme le récit d’un praticien. La solution consiste en des mesures préventives : alertes budgétaires, durées maximales de session et limites de fréquence des appels aux outils dès le début. La plateforme permettra volontiers à un agent de s’endetter progressivement.
LangGraph : le mur des systèmes multi-agents. Selon une analyse de Latenode, plus de 75 % des systèmes multi-agents deviennent plus difficiles à gérer dès l’ajout de cinq agents, avec des conditions de course, des blocages, une corruption de l’état et une épuisement de la mémoire. Il s’agit là d’une étude d’analyste et non d’une recherche indépendante, bien qu’elle corresponde à ce que Replit et Uber ont décrit. Le problème ne se manifeste ni avec le premier ni avec le troisième agent ; il apparaît au sixième agent, lorsque les arêtes du graphe cessent d’être évidentes, que l’état des points de contrôle devient difficile à comprendre et que les points de contrôle gérés par un humain se retrouvent embrouillés avec les branches asynchrones. Les équipes qui réussissent avec LangGraph maintiennent leurs graphes en dessous de cinq nœuds ou investissent fortement dans l’observabilité. Celles qui échouent tentent de mettre en place un essaim de dix agents sans recourir à aucune de ces solutions.
Ces modes de défaillance sont d’ordre architectural plutôt que opérationnel, donc une meilleure ingénierie ne les éliminera pas. Vous choisissez la plateforme dont les défaillances vous êtes capable de supporter.
Récolte l’après-midi
Trois questions résolvent la plupart des cas.
Faut-il l’expédier ce trimestre ? Si oui, Managed Agents est la solution par défaut, car pour les équipes ne disposant pas de exigences VPC-SC, rien d’autre ne raccourcit autant le parcours du prototype à la production. Atténuez l’attachement à Claude en écrivant dès maintenant de la logique d’agent en utilisant les interfaces du Claude Agent SDK, afin de pouvoir passer ultérieurement à Bedrock ou Vertex auto-hébergés.
Le design comporte-t-il plus de cinq branches, ou nécessite-t-il une approbation humaine à plusieurs étapes ? Dans ce cas, optez pour LangGraph, à condition que votre équipe dispose de la capacité nécessaire sur la plateforme. Klarna, Uber et Replit en sont des exemples ; la courbe d’apprentissage plus raide vous permettra d’utiliser des outils de base qui ne vous surprendront pas à 3 heures du matin.
Votre charge de travail est-elle déjà hébergée sur Google Cloud et nécessite-t-elle VPC Service Controls ? Dans ce cas, ADK avec Agent Engine représente la solution la plus simple. La conformité est incluse gratuitement, et le coût de stockage est le plus bas parmi les trois options. Prévoyez également un budget pour les frais liés aux boucles de réflexion lors de l’évaluation.
Résumé sous forme de tableau dans votre esprit : pour les livraisons de ce trimestre, Managed Agents est le plus rapide, LangGraph nécessite un investissement dans la plateforme et ADK exige des compétences internes en GCP. Pour les architectures complexes comportant plus de cinq branches ou validations, Managed Agents est limité en raison de sa structure rigide ; LangGraph constitue le choix par défaut, tandis qu’ADK couvre la plupart des cas grâce à ses primitives. Si l’utilisation de GCP avec VPC-SC est obligatoire, Managed Agents requiert des travaux d’intégration supplémentaires, LangGraph implique que vous devez construire le périmètre de sécurité vous-même, et ADK l’hérite nativement. Pour les charges de travail multi-modèles, Managed Agents ne fonctionne qu’avec Claude (utilisez l’Agent SDK pour la portabilité), tandis que LangGraph est indépendant des modèles, et ADK traite Gemini comme un modèle de premier plan, les autres modèles étant accessibles via LiteLLM ou des endpoints compatibles OpenAI.
L’AWS Bedrock AgentCore mérite une brève mention en tant que quatrième option. Il convient aux entreprises qui gèrent tout sur AWS et souhaitent disposer d’une seule couche de calcul sous le Claude Agent SDK, LangGraph et CrewAI, au prix de 0,0895 dollar par vCPU-heure et 0,00945 dollar par GB-heure. Il s’agit d’une solution infrastructurelle plutôt que d’un choix de framework, ce qui le fait sortir du cadre de cette comparaison.
Essayer le même agent sur les trois
Mettez en place un petit agent dans chaque environnement : un résumé hebdomadaire qui récupère trois articles récents d’arXiv sur la génération augmentée par recherche, exécute un bref script d’évaluation et rédige une seule page. Suivez le temps nécessaire pour passer du clone à une exécution fonctionnelle, le coût de chaque exécution, ainsi que la rapidité avec laquelle vous pouvez déterminer pourquoi une exécution a échoué.
Pour les agents gérés, le fragment présenté précédemment constitue l’ensemble du cadre de travail : création d’une session, création d’un exécution et un flux d’événements avec gestion des erreurs en cas de déconnexion. Définissez ANTHROPIC_API_KEY, exécutez-le une fois, forcez ensuite un redémarrage du client et vérifiez que le journal de la session reste intact en vous reconnectant via GET /runs/{id}/events. Avec une clé API Claude, une première exécution réussie ne devrait pas durer plus d’une heure.
Avec LangGraph, le graph ne représente que la moitié du travail. L’autre moitié consiste en un outil de vérification Postgres ainsi qu’en un endroit pour le déployer. La configuration minimale se présente comme suit :
# 1. Postgres (any managed or docker-run instance)
export POSTGRES_DSN="postgresql://user:pass@host:5432/langgraph"
# 2. Install and run the compiled graph
pip install "langgraph[postgres]" langsmith
python summarizer_graph.py # runs the StateGraph from above
# 3. Deploy (LangSmith Deployment OR self-hosted)
pip install langgraph-cli
langgraph deploy --config langgraph.json # SaaS tier
# or: docker run ghcr.io/langchain-ai/langgraph-api ...
Prévoyez une demi-journée. Les premières trente minutes sont consacrées à la configuration, et les trois heures suivantes servent à déterminer l’emplacement du point de contrôle humain ainsi que la manière de tenter à nouveau en cas de panne de l’outil.
Pour ADK, SequentialAgent représente la logique de l’agent, tandis que la partie liée à l’exécution comprend l’authentification via gcloud ainsi que le déploiement d’un Agent Engine. Structure minimale requise :
# 1. Auth + enable APIs
gcloud auth application-default login
gcloud services enable aiplatform.googleapis.com
# 2. Install and deploy
pip install google-adk google-cloud-aiplatform
python deploy_summarizer.py # runs agent_engines.create(...)
# 3. Governance wiring (inherited, not configured in code)
# - VPC-SC perimeter: Console > Security > VPC Service Controls
# - CMEK: Console > Security > Cryptographic Keys
# - Budget alert: Console > Billing > Budgets & Alerts
Prévoyez également une demi-journée ici, principalement consacrée à la configuration d’IAM et de VPC-SC, ce qui est justement la raison pour laquelle vous avez choisi ADK en premier lieu.
Faites fonctionner chacun d’eux pendant une semaine. Comparez votre facture LangSmith, les frais horaires de Claude et la facture Vertex AI Agent Engine, puis lisez les trois rapports d’erreur. Optez pour la plateforme qui correspond à la véritable capacité d’ingénierie de votre équipe.
À retenir
En 2026, les plateformes d’agents sont passées de la question « pouvons-nous le construire ? » à « quel compromis devrons-nous accepter pendant des années ? ». Les trois solutions présentées ici disposent de clients réels, de chiffres concrets, de modes d’échec réels et de tarifs réels, et aucune n’est strictement meilleure. Elles s’adressent à des besoins opérationnels différents. Le choix dépend d’une auto-évaluation de votre équipe de plateforme, de vos exigences en matière de conformité et de votre capacité à gérer des tâches d’ingénierie ; choisissez donc en fonction de l’équipe que vous avez, et non de celle que vous aimeriez avoir.
- Managed Agents vous permet de passer du prototype à la production en quelques jours, et non en mois, mais il vous lie à Claude. Si plusieurs fournisseurs de modèles doivent être utilisés, codez en utilisant le Claude Agent SDK et hébergez-le vous-même sur Bedrock, Vertex AI ou Azure AI Foundry.
- Testez d’abord la compression. Créez une tâche qui n’a besoin que des 20 % les plus précoces de la session après le seuil des 80 %, car le blog technique d’Anthropic indique que c’est là que les sessions échouent silencieusement.
- LangGraph convient lorsque votre architecture comporte plus de cinq branches ou nécessite une approbation humaine à plusieurs étapes. Si vous essayez de vous appuyer sur un framework de niveau supérieur, vous construisez quelque chose de faux avec, alors passez au modèle graphique avant d’atteindre les limites liées aux multiples agents.