LangChain Deep Agents: a structured runtime for planning, memory, and context isolation

LangChain a publié Deep Agents le 15 mars 2026 — un runtime structuré qui offre aux agents IA une planification intégrée, une gestion du contexte basée sur le système de fichiers et une délégation à des sous-agents. Il comble une lacune que la plupart des frameworks d'agents ont ignorée : ce qui se passe lorsqu'une tâche nécessite plus que quelques appels d'outils pour être achevée.

Ce qu'est réellement Deep Agents

Deep Agents est un « harnais d'agent » (agent harness) construit au-dessus de LangGraph, le runtime de LangChain pour l'exécution durable. Il regroupe un ensemble de paramètres par défaut et d'outils intégrés autour de la boucle standard d'appel d'outils (tool-calling loop). Les développeurs bénéficient de la planification, du déchargement de contexte et de la délégation de sous-tâches sans avoir à construire ces systèmes à partir de zéro.

La bibliothèque est livrée avec plusieurs composants essentiels : un outil de planification write_todos, des outils de système de fichiers (read_file, write_file, edit_file, ls, glob, grep), un accès shell sandboxé via execute, un outil task pour générer des sous-agents, et une auto-résumérisation pour la gestion du contexte.

L'appel à create_deep_agent(...) renvoie un CompiledStateGraph — un objet LangGraph standard. Cela signifie que Deep Agents n'est pas une couche d'abstraction séparée. Il s'exécute sur le même runtime, prend en charge le streaming, LangGraph Studio et les checkpointers nativement.

Pourquoi la planification est importante pour les agents multi-étapes

La plupart des agents LLM fonctionnent bien pour des séquences d'appels d'outils courtes : rechercher sur le web, analyser un résultat, renvoyer une réponse. Ils commencent à se dégrader lorsque la tâche nécessite dix, vingt ou cinquante étapes avec des décisions intermédiaires.

Sans couche de planification, le modèle improvise chaque étape en se basant sur ce qui se trouve actuellement dans la fenêtre de prompt. Deep Agents résout ce problème avec write_todos, un outil intégré qui permet à l'agent de décomposer une tâche complexe en étapes discrètes, de suivre les progrès et de mettre à jour le plan au fur et à mesure que de nouvelles informations apparaissent.

C'est utile pour des workflows concrets : des tâches de recherche qui nécessitent plusieurs recherches et recoupements, des sessions de codage s'étendant sur plusieurs fichiers, ou des travaux d'analyse où chaque étape dépend du résultat précédent. L'agent écrit son plan, l'exécute et marque les éléments comme terminés au fur et à mesure.

Gestion du contexte basée sur le système de fichiers

Le dépassement de la fenêtre de contexte (context window overflow) est le principal mode d'échec pour les agents à exécution longue. Une seule fenêtre de contexte Claude Opus 4 contient environ 200 000 tokens. Cela semble beaucoup jusqu'à ce qu'un agent accumule des résultats de recherche, des sorties de code, des notes intermédiaires et l'historique des conversations sur des dizaines d'étapes.

Deep Agents utilise des outils de système de fichiers pour résoudre ce problème. Au lieu de tout garder dans le prompt actif, l'agent écrit les sorties volumineuses — code généré, notes de recherche, rapports intermédiaires — dans des fichiers et les récupère en cas de besoin. Cette approche réduit la pression sur la fenêtre de prompt et maintient le contexte de travail pertinent.

Le système prend en charge plusieurs types de backends : StateBackend (éphémère, stocké dans l'état LangGraph), FilesystemBackend, LocalShellBackend, StoreBackend et CompositeBackend. Le réglage par défaut est StateBackend, qui stocke un système de fichiers éphémère pour un thread unique.

Compression autonome du contexte

Le 11 mars, LangChain a publié une fonctionnalité complémentaire : la compression autonome du contexte. Plutôt que de compacter à un seuil de tokens fixe (l'approche standard, généralement à 85 % du contexte disponible), Deep Agents expose désormais un outil qui permet à l'agent de déclencher lui-même la compression.

Le raisonnement est simple. Il y a de bons et de mauvais moments pour compacter le contexte :

• Mauvais : en plein milieu d'un refactoring, quand l'agent a besoin des détails récents pour effectuer des modifications correctes.
• Bon : après avoir terminé un livrable, avant de commencer une nouvelle tâche, ou après avoir extrait une conclusion d'une large phase de recherche.

En donnant au modèle le contrôle sur le moment de la compression, le système évite les situations où un seuil fixe déclenche le compactage au pire moment possible. La compression conserve les messages récents (10 % du contexte disponible) et résume tout ce qui précède ce point.

Cela suit ce que LangChain appelle « the bitter lesson » (la leçon amère) — laisser le modèle gérer davantage de ses propres décisions opérationnelles plutôt que de coder en dur le comportement du harnais.

Sous-agents et isolation du contexte

Deep Agents inclut un outil task intégré pour générer des sous-agents avec un contexte isolé. L'agent principal peut déléguer des sous-tâches spécifiques — par exemple, rechercher une API unique, écrire un fichier de test ou résumer un document — à un sous-agent qui démarre avec une fenêtre de contexte propre.

Cela répond à un mode d'échec courant. Lorsqu'un seul thread d'agent accumule plusieurs objectifs, des sorties d'outils et des décisions temporaires, la qualité de la sortie chute. Le modèle perd le fil de ce qu'il faisait. L'isolation des sous-agents maintient le thread principal propre tout en permettant un travail plus approfondi sur des sous-tâches spécifiques.

Le modèle est similaire à la façon dont OpenClaw, Codex CLI et d'autres harnais d'agents gèrent la délégation, mais Deep Agents l'intègre directement dans le runtime standard plutôt que de laisser cela aux développeurs d'applications.

Mémoire à long terme à travers les conversations

Deep Agents prend en charge la mémoire persistante via le Memory Store de LangGraph. Cela permet à l'agent de sauvegarder et de récupérer des informations provenant de conversations précédentes — préférences de l'utilisateur, contexte spécifique au projet ou décisions prises lors de sessions antérieures.

Il s'agit d'une couche supérieure à la gestion du contexte basée sur le système de fichiers. Le système de fichiers gère l'état au sein d'une session. Le Memory Store gère la persistance entre les sessions. Ensemble, ils donnent à l'agent à la fois une mémoire de travail et un rappel à long terme.

Comment démarrer

La configuration est minimale. Installez deepagents ainsi que tous les fournisseurs d'outils dont vous avez besoin :

pip install -qU deepagents tavily-python

from deepagents import create_deep_agent

def search_web(query: str) -> str:
    """Search the web for information."""
    from tavily import TavilyClient
    client = TavilyClient()
    return client.search(query)["results"]

agent = create_deep_agent(
    model="anthropic:claude-opus-4",
    tools=[search_web],
    system_prompt="You are a research assistant."
)

result = agent.invoke({"messages": [{"role": "user", "content": "Research the latest AI agent frameworks"}]})

Pour la compression autonome du contexte, ajoutez le middleware de résumérisation :

from deepagents.middleware.summarization import create_summarization_tool_middleware
from deepagents.backends import StateBackend

agent = create_deep_agent(
    model="anthropic:claude-opus-4",
    middleware=[
        create_summarization_tool_middleware("anthropic:claude-opus-4", StateBackend),
    ],
)

Comparaison de Deep Agents avec d'autres frameworks d'agents

Fonctionnalité	Deep Agents	OpenClaw	AutoGen	CrewAI
Planification intégrée	Oui (write_todos)	Via skills	Manuel	Décomposition de tâches
Contexte fichiers	Oui (plusieurs backends)	Oui (workspace)	Non	Non
Isolation sous-agents	Oui (outil task)	Oui (sessions_spawn)	Oui (agents)	Oui (crews)
Compression contexte	Autonome	Auto-compaction	Manuel	Non
Mémoire long terme	LangGraph Memory Store	SOUL.md + fichiers	Manuel	Limité
Runtime	LangGraph	Node.js daemon	Python	Python
Déploiement	LangGraph Cloud	Auto-hébergé	Auto-hébergé	Auto-hébergé

Qui devrait utiliser Deep Agents

Deep Agents est conçu pour les développeurs qui utilisent déjà ou envisagent d'utiliser LangChain et qui ont besoin d'agents capables de gérer des tâches durant plus de quelques appels d'outils. Les cas d'utilisation spécifiques incluent :

• Automatisation de la recherche : tâches nécessitant plusieurs recherches, le recoupement de sources et la production de résultats structurés.
• Génération de code : projets multi-fichiers où l'agent doit suivre les dépendances entre les fichiers.
• Analyse de données : exploration itérative où chaque étape dépend des découvertes de la précédente.
• Traitement de documents : documents longs qui dépassent les limites de la fenêtre de contexte et doivent être traités par morceaux.

Si les tâches de votre agent se terminent en moins de cinq appels d'outils, des agents LangChain plus simples ou des appels d'API directs sont probablement suffisants. Deep Agents apporte de la valeur lorsque la tâche est suffisamment complexe pour que la planification, le déchargement de contexte et la délégation fassent une différence mesurable.

Conclusion

Deep Agents is a structured runtime from LangChain for multi-step AI agents, released March 15, 2026. It includes built-in planning (write_todos), filesystem-based context management, and subagent delegation. Autonomous context compression lets the agent decide when to compact its own context window. The system runs on LangGraph and returns a standard CompiledStateGraph, so existing LangGraph tooling works. Persistent memory across conversations is supported through LangGraph's Memory Store. Deep Agents is best suited for tasks that require more than five tool calls and benefit from planning and context isolation.

Points Clés

• Deep Agents est un runtime structuré de LangChain, lancé le 15 mars