Deep Agents vs LangGraph : de quelle couche avez-vous réellement besoin ?

Construire un agent implique bien plus que connecter un LLM à quelques outils. Vous devez également décider de la façon dont l'agent gère l'état, traite le contexte, appelle les outils, exécute les tâches et détermine l'étape suivante.

LangGraph et Deep Agents résolvent ces problèmes à des niveaux d'abstraction différents. LangGraph fournit aux développeurs les primitives pour définir et contrôler le flux d'exécution d'un agent, tandis que Deep Agents offre un harness d'agent pré-construit et de plus haut niveau au-dessus de LangGraph.

Tous deux résolvent le même problème sous-jacent. Un modèle raisonne mais ne peut pas agir. Il n'ouvrira pas de fichier, n'appellera pas d'API, n'exécutera pas le code qu'il vient d'écrire et ne se souviendra pas de ce qu'il a décidé quatre tours plus tôt. Quelque chose doit envelopper le modèle pour combler cet écart, puis continuer à le combler aussi longtemps que dure la tâche. LangGraph vous donne les pièces pour construire cet élément. Deep Agents vous le livre déjà assemblé.

Qu'est-ce que LangGraph ?

LangGraph est un runtime d'agent. Vous modélisez le flux de travail sous la forme d'un graphe orienté : les nœuds sont des opérations distinctes, les arêtes définissent ce qui s'exécute ensuite, et un schéma d'état typé traverse chaque étape. L'exécution parcourt votre structure jusqu'à ce qu'un nœud renvoie END.

Une construction avec LangGraph ressemble généralement à ceci :

• Définir le schéma d'état. Un objet typé que chaque nœud lit et modifie.
• Écrire les nœuds. Chacun est une fonction : appeler un modèle, solliciter un outil, transformer l'état, valider un élément.
• Relier les arêtes. Des séquences fixes, ainsi que des arêtes conditionnelles qui bifurquent selon l'état à ce moment précis.
• Ajouter des checkpointers. Une persistance qui permet à une exécution interrompue de reprendre depuis la dernière étape terminée au lieu du début.
• Ajouter des interruptions. Des points de pause où un humain examine ou approuve avant que l'exécution ne se poursuive.

Les checkpointers et les interruptions sont les véritables facteurs différenciateurs ici, et c'est pourquoi LangGraph s'est retrouvé sous presque tout le reste de la suite LangChain. Le create_agent de LangChain ainsi que Deep Agents fonctionnent tous deux dessus.

LangGraph fonctionne le mieux lorsque :

• Le flux de travail a une structure définie, et cette structure intègre une connaissance du domaine qu'il ne faut pas laisser au jugement d'un modèle
• Les étapes déterministes et les étapes de modèle se mélangent dans le même pipeline
• Un humain doit approuver à un point précis, et non "quelque part dans la boucle"
• Les exécutions sont suffisamment longues pour qu'une reprise à partir d'un checkpoint soit essentielle
• Vous avez besoin de ramifications ou de boucles de retour vers des étapes antérieures qu'aucune boucle fixe ne permettrait

L'exemple propre à LangChain est un pipeline de demande de location : extraire les revenus et l'historique de crédit à partir de documents, évaluer par rapport aux critères du propriétaire, puis approuver automatiquement, rejeter ou escalader les cas limites. Seule la première étape fait appel à un LLM. Le reste est du code fixe, et doit le rester.

Que sont les Deep Agents ?

Deep Agents est un harness d'agent. Il utilise la même boucle centrale que le create_agent de LangChain, mais de manière opinionnée, en intégrant par défaut des pratiques d'ingénierie de contexte. LangChain le décrit comme l'agent central plus un ensemble de middlewares, et en dessous, cela reste un graphe LangGraph.

Ce qui est fourni d'origine :

• Un système de fichiers, afin que l'agent lit et écrive du contexte qu'il ne devrait pas transporter dans la fenêtre de contexte
• Des sous-agents, qui exécutent des travaux spécialisés sans engorger le thread principal
• Des skills, des instructions et des scripts que l'agent charge à la demande
• De la mémoire, pour que l'agent conserve ses apprentissages d'une exécution à l'autre
• Une structure de planification, la mécanique qui décompose une tâche avant de la traiter

Vous obtenez un agent à partir de create_deep_agent avec un modèle, un ensemble d'outils et un prompt système. Aucun graphe à concevoir.

La différence avec LangGraph réside dans la responsabilité de l'écriture de la boucle. Avec LangGraph, vous déclarez les nœuds et les conditions, et le flux de contrôle vous appartient. Avec Deep Agents, vous fournissez des outils et des instructions puis vous lancez l'exécution, et le modèle décide de la suite dans une boucle conçue par quelqu'un d'autre. Si vous souhaitez une version plus détaillée de ce principe, nous l'avons rédigée séparément dans agent harness vs agent framework.

Deep Agents fonctionne le mieux lorsque :

• Le cheminement de l'agent dépend de ce que l'étape précédente a trouvé, il n'y a donc aucun graphe prédéfini à tracer
• Vous souhaitez disposer d'un agent opérationnel en quelques heures plutôt qu'en quelques jours
• Il s'agit de recherche, d'investigations en plusieurs étapes ou de tout ce qui se déploie à travers plusieurs sources
• Vous êtes déjà investi dans LangGraph et souhaitez la boucle sans avoir à la construire manuellement
• Votre équipe préfère hériter des décisions de gestion du contexte plutôt que d'avoir à les concevoir

Deep Agents vs LangGraph : Différences fondamentales

Tous deux visent le même résultat tout en se situant à des niveaux différents de la même pile, c'est pourquoi la question "lequel est le meilleur" n'a pas de réponse univoque. L'un vous demande de concevoir le comportement de l'agent. L'autre en décide en grande partie pour vous et vous facture en tokens les choix qu'il a faits de manière généreuse.

Une meilleure alternative pour la production : le harness d'agent TrueForge

LangChain Deep Agents résout une grande partie du travail complexe au niveau d'un agent individuel, y compris la planification, les sous-agents, les outils de système de fichiers, les skills, la mémoire et l'exécution sur le long terme. Mais lorsque vous faites fonctionner des agents sur plusieurs équipes, le problème ne consiste plus à construire l'agent mais à gérer la flotte.

TrueForge est le harness d'agent open-source et neutre vis-à-vis des fournisseurs développé par TrueFoundry pour cette couche de runtime. Il exécute la boucle d'agent autour du modèle, incluant la planification, les appels d'outils, la gestion de contexte, les approbations et l'état de session, tout en vous permettant d'apporter vos propres modèles, serveurs MCP et fournisseurs de sandboxes.

Vous pouvez l'exécuter localement avec npx @truefoundry/trueforge, ou déployer le même harness pour une équipe en utilisant Docker Compose ou Helm. Consultez la documentation TrueForge.

Optimisation du runtime d'agent

TrueForge fournit également plusieurs mécanismes pour contrôler le volume de contexte et de données d'outils qui parviennent au modèle.

Le chargement différé d'outils signifie que les schémas d'outils MCP se chargent à la demande au lieu d'encombrer la fenêtre dès le départ. Le Code Mode permet à l'agent d'enchaîner plusieurs appels d'outils au sein d'un seul script en sandbox, de sorte que seul le résumé imprimé entre dans le contexte plutôt que chaque résultat intermédiaire. Les réponses d'outils volumineuses sont déchargées dans un fichier sandbox et remplacées par un chemin et un aperçu. La compaction se déclenche à 80 % de la longueur de contexte du modèle et remplace l'historique ancien par un résumé structuré, ce qui résout directement la question du rejeu. Les sous-agents fonctionnent avec leur propre contexte propre et ne renvoient que le résultat.

Le modèle de sandbox est un autre levier. La plupart des harnesses englobent toute la session dans un conteneur. TrueForge traite la sandbox comme un outil et n'en instancie une que lorsque l'agent a réellement besoin d'exécuter du code, de sorte qu'un seul serveur peut exécuter de nombreux agents simultanément et que les tours sans exécution de code restent peu coûteux.

Bien plus qu'une bibliothèque Python

TrueForge est également structuré comme un runtime plutôt que comme une simple interface de bibliothèque.

Le serveur central exécute la boucle d'agent et fournit le streaming, les portes d'approbation, la délégation aux sous-agents, la compaction et les sessions persistantes. Une API HTTP et un SDK TypeScript (@truefoundry/trueforge-sdk) exposent les mêmes fonctionnalités de manière programmatique. Une interface utilisateur de chat et un SDK UI distincts (@truefoundry/trueforge-ui) peuvent être utilisés directement, personnalisés ou intégrés dans un autre produit.

Cela offre aux équipes une surface de déploiement au-delà de la définition de l'agent Python elle-même : le même runtime peut alimenter une application, une API ou une expérience d'agent intégrée.

Les modèles, les serveurs MCP et les fournisseurs de sandboxes sont tous configurables. Lorsqu'un modèle moins cher est disponible, vous le pointez sans réécrire l'agent, c'est ainsi que la même exécution de benchmark sur GLM-5.2 a résolu les mêmes ~11 tâches sur 14 pour 2,90 $ par exécution.

Benchmark Deep Agents vs TrueForge

La différence entre un framework d'agent et un runtime d'agent devient plus claire lorsqu'on les compare sur les mêmes charges de travail. TrueFoundry a évalué TrueForge et Deep Agents sur l'Enterprise-Bench de DevRev, qui se compose de 14 tâches d'entreprise multi-systèmes. Chaque tâche exige que l'agent planifie, appelle des outils MCP sur un CRM, un outil de suivi de projet et un gestionnaire de documents, combine les résultats et renvoie une réponse conforme à la grille d'évaluation. Les deux harnesses ont exécuté les mêmes tâches avec les mêmes serveurs MCP, et les réponses ont été évaluées à l'aveugle par un LLM juge.

En maintenant Opus 4.8 constant, les deux harnesses ont obtenu une précision similaire sur les tâches, mais leurs coûts d'exécution étaient différents :

Le benchmark montre une différence relativement faible en matière de précision des tâches, mais une différence bien plus importante dans le coût d'exécution. TrueForge a utilisé moins d'un quart des tokens consommés par Deep Agents et s'est avéré environ 2,5 fois moins cher par exécution sur le même modèle.

La couche de runtime pour les agents IA en production

Exécutez des agents en production grâce à un runtime open-source pour vos modèles, outils MCP, sandboxing, approbations et observabilité.

Explorer TrueForge

Voir sur GitHub

Cette différence découle principalement de la façon dont les deux runtimes gèrent l'orchestration et le contexte. Deep Agents fournit des fonctionnalités telles que la planification, un système de fichiers virtuel et des sous-agents, mais celles-ci peuvent aussi ajouter plus d'orchestration et de contexte à chaque tour. TrueForge adopte une approche plus sobre, en utilisant des appels d'outils ciblés et la compaction de contexte pour éviter de renvoyer de façon répétée d'historiques volumineux et des réponses d'outils au modèle. Cela est crucial car le coût d'un agent n'est pas déterminé uniquement par le prix du modèle. Deux systèmes d'agents exécutant le même modèle peuvent avoir une consommation de tokens très différente selon la façon dont ils implémentent la planification, l'utilisation des outils, la gestion du contexte et les sous-agents.

Connecter le runtime d'agent à la couche plateforme

TrueForge peut également se connecter aux AI Gateway et MCP Gateway de TrueFoundry pour fournir les contrôles nécessaires lorsque les agents dépassent le stade des projets isolés, notamment l'accès centralisé aux modèles, les identifiants MCP, le RBAC, les budgets, les guardrails, la rotation des identifiants et les traces unifiées. Cela déplace ces problématiques en dehors des définitions d'agents individuels vers une couche de plateforme partagée.

Pour les équipes évaluant Deep Agents pour la production, ce benchmark rappelle utilement que le framework n'est qu'une partie de la pile. L'architecture de runtime autour de l'agent peut avoir un impact significatif sur la consommation de tokens, la latence et le coût. TrueForge est conçu pour fournir cette couche de runtime tout en conservant le choix des modèles et de l'infrastructure ouverts.

Alors, lequel devriez-vous choisir ?

Optez pour LangGraph lorsque la valeur réside dans la forme même du graphe. Des étapes de conformité sur des nœuds spécifiques, des boucles conditionnelles vers des étapes antérieures, un pipeline où seule une étape doit toucher un modèle. Si vous êtes déjà sur LangGraph et que le flux est réellement en forme de graphe, restez-y.

Optez pour un harness lorsque vous vous surprenez à construire manuellement une boucle qui existe déjà ailleurs. La question est alors seulement de savoir quel harness choisir, et c'est une question de gestion du contexte : lisez donc la documentation sur la compaction, le déchargement et le chargement différé avant de vous engager. Si aucune de ces notions n'est mentionnée, vous faites face à un framework portant une étiquette de harness.

Optez spécifiquement pour deepagents si vous souhaitez bénéficier de l'écosystème et des abstractions de LangChain et que le profil de tokens est acceptable pour votre charge de travail. Les exécutions courtes ne verront pas la différence.

Optez pour TrueForge si les exécutions longues constituent votre cas d'usage classique, si vous avez besoin d'une API HTTP ou d'une UI intégrée plutôt que d'une bibliothèque, si vous voulez une licence MIT sans engagement envers un écosystème, ou si le coût par exécution doit résister aux questions de votre équipe financière. Notre analyse des alternatives à LangGraph couvre les options au niveau de la couche framework si c'est cette couche dont vous avez réellement besoin.

Et la réponse combine souvent les deux. Un framework gère l'orchestration entre les agents, ou le flux de travail déterministe au sein duquel se trouve un agent piloté par un harness. Un harness exécute les agents eux-mêmes. Les deux pièges à éviter sont d'utiliser un framework pour reconstruire une boucle que vous auriez pu hériter, et de forcer un harness à suivre une séquence de conformité rigide en la décrivant dans un prompt en espérant que cela fonctionne.

FAQ

Q : Quelle est la différence entre deep agents et LangGraph ?

A : LangGraph est un runtime d'agent et Deep Agents est un harness d'agent construit par-dessus. Avec LangGraph, vous déclarez les nœuds, les arêtes et l'état, et vous écrivez le flux de contrôle vous-même. Avec Deep Agents, la boucle est déjà écrite, accompagnée d'un système de fichiers, de sous-agents, de skills et de mémoire : vous fournissez simplement les outils et les instructions. En dessous, Deep Agents se compile sous la forme d'un graphe LangGraph.

Q : Deep Agents remplace-t-il LangGraph ?

A : Non, et il ne le peut pas, car il s'exécute sur LangGraph. Un harness vous fournit une boucle fixe pilotée par un modèle. Si votre flux de travail nécessite une topologie arbitraire, des étapes de validation sur des nœuds nommés ou des boucles conditionnelles vers des étapes antérieures, aucun harness ne saura l'exprimer et LangGraph reste l'outil adéquat. De nombreux systèmes en production utilisent les deux à des couches différentes.

Q : Quel outil est le moins cher à exécuter, deepagents ou un autre harness ?

A : Sur notre test Enterprise-Bench, deepagents sur Opus 4.8 a consommé 16,5 M de tokens pour un coût de 21 $ par exécution, contre 3,8 M de tokens et 8,50 $ pour TrueForge sur le même modèle et les mêmes 14 tâches, avec une précision équivalente à une tâche près. L'écart provient du rejeu du contexte accumulé au lieu de sa compaction, en plus des éléments de structure transportés à chaque tour.

Q : Puis-je exécuter l'un de ces outils dans mon propre VPC ou on-premise ?

A : Oui. Tous deux sont des projets open source auto-hébergeables. TrueForge s'exécute localement à partir d'une seule commande npx, ou via Docker Compose et Helm pour les déploiements d'équipe avec Postgres, Redis, des répliques et l'authentification OIDC. La plateforme gérée de TrueFoundry s'exécute également en mode auto-hébergé, on-premise, air-gapped ou hybride, afin qu'aucune donnée ne quitte votre domaine.

Q : Comment gouverner les modèles et les serveurs MCP sur un grand nombre d'agents ?

A : Via une couche de passerelle (gateway), dès lors que les clés gérées manuellement ne suffisent plus. L'AI Gateway de TrueFoundry rassemble plus de 1 000 LLM derrière une API unique compatible OpenAI, avec environ 3 à 4 ms de latence ajoutée et plus de 350 RPS sur un seul vCPU. Elle intègre le RBAC, des budgets, des guardrails et la rotation des identifiants, ainsi que des traces OpenTelemetry vers Grafana, Datadog ou Prometheus. Les agents construits sur LangGraph, deepagents ou tout autre système sont gouvernés de la même façon.

Lectures associées

• Agent Harness vs Agent Framework : quelles sont les vraies différences ? : la distinction de catégorie qui sous-tend toute cette décision
• Alternatives à LangChain Deep Agents : le panorama des harnesses si deepagents ne convient pas
• TrueForge vs Claude Managed Agents : jusqu'à 75 % moins cher : méthodologie et résultats complets sur Enterprise-Bench
• Meilleurs harnesses d'agents open source : comparaison des 5 meilleurs projets : comment se positionnent les options open source
• Alternatives à LangGraph : comparaison de 5 options pour 2026 : si la couche framework est celle dont vous avez besoin

Conclusion

Le choix entre Deep Agents et LangGraph se résume à la couche à laquelle se situe votre problème, et vous pouvez trancher par une seule question : le parcours de l'agent a-t-il une structure que vous souhaitez concevoir, ou se découvre-t-il au fur et à mesure de l'exécution ?

S'il a une structure définie, choisissez LangGraph. Si ce n'est pas le cas, il vous faut un harness, et le facteur différenciateur réside dans ce que ce harness fait de votre fenêtre de contexte au quarantième tour. C'est un élément qui mérite d'être mesuré avant de construire dessus.

npx @truefoundry/trueforge vous permet d'obtenir un agent fonctionnel en une minute environ, ou découvrez comment TrueForge gère le contexte sur les exécutions longues.