Apprendre de nouvelles compétences aux Deep Agents : planification, sous-agents et fichiers SKILL.md

L’IA agente concerne des systèmes composés de plusieurs agents coopératifs qui divisent un problème complexe et enchevêtré, échangent des informations et travaillent comme une petite équipe de spécialistes. Un chatbot isolé répond à une seule question. Un système agent nécessite de la planification, de la mémoire et l’utilisation d’outils afin de pouvoir mener à bien une tâche en plusieurs étapes. L’apprentissage par renforcement (RL) est la méthode classique pour créer des agents qui apprennent par essais et erreurs : un réseau profond observe son environnement, choisit des actions telles que l’utilisation d’outils ou l’exécution de code, et reçoit des récompenses qui orientent sa stratégie. L’apprentissage par renforcement profond a permis des performances surhumaines au go et aux échecs, ainsi que de bons résultats en robotique, en maximisant constamment la récompense cumulative attendue. Appliquer ces idées aux agents alimentés par des LLM ouvre une possibilité intéressante : des agents capables d’acquérir des routines ou des compétences réutilisables, puis de planifier et d’exécuter leurs actions avec moins d’effort.

Qu’est-ce qui rend un agent « profond » ?

Les agents profonds élargissent les capacités d’un assistant LLM grâce à quatre fonctionnalités :

1. Un outil de planification qui divise les tâches complexes en étapes.
2. Des sous-agents pour travailler en parallèle et isoler le contexte.
3. Un système de fichiers persistant qui sert également de mémoire.
4. Un prompt système détaillé indiquant les objectifs et les contraintes.

Ensemble, ces éléments permettent à un agent de planifier, de conserver son état et d’exécuter des workflows complexes sans que son contexte de prompt ne soit saturé. Un chatbot superficiel répond une seule fois. Un agent profond itère : il planifie, cherche, enregistre les résultats, les synthétise et les affine. Lorsqu’on lui demande un rapport, il peut établir une liste de tâches, effectuer des recherches ou des analyses en ligne, stocker des notes dans des fichiers, puis rédiger et réviser, tout cela guidé par le modèle sans intervention humaine.

Apprentissage par renforcement et l’origine des compétences

Le RL constitue la base des agents qui apprennent en agissant. L’agent observe un état, entreprend une action et reçoit une récompense ou une pénalité ; en maximisant la somme attendue des récompenses futures, il améliore sa politique d’action. Il diffère de l’apprentissage supervisé, qui dispose de labels, et de l’apprentissage non supervisé, qui cherche des structures cachées, car il traite de décisions séquentielles dans un contexte d’incertitude. Le deep RL utilise des réseaux neuronaux comme approximateurs de fonctions afin de pouvoir gérer des images, du texte et des données de capteurs brutes. Parmi les réalisations notables figurent les Deep Q-Networks pour Atari, ainsi que des méthodes basées sur des gradients de politique comme PPO et A2C pour les jeux de contrôle continu et de stratégie. Des recherches plus récentes se concentrent sur l’apprentissage hiérarchique des compétences, où les agents découvrent des options, c’est-à-dire des actions étendues dans le temps permettant de résoudre des sous-objectifs, ce qui favorise à la fois l’exploration et le transfert de connaissances.

Pour les agents LLM, l’apprentissage par renforcement joue deux rôles. D’une part, il permet d’affiner le modèle lui-même à l’aide de signaux de feedback. L’RLHF, par exemple, a permis d’aligner les modèles pour en faire des outils plus sûrs et plus pertinents. DeepSeek-R1 a démontré qu’un apprentissage par renforcement pur, sans données étiquetées, peut entraîner un modèle de raisonnement capable de rivaliser avec les meilleurs systèmes en mathématiques et en programmation : le modèle génère plusieurs réponses, un évaluateur automatique récompense celles qui sont correctes et pénalise les autres, et au fil de nombreuses itérations, un algorithme comme PPO améliore la stratégie de prise de décision du modèle. Les pipelines réels peuvent ajouter un affinage supervisé ainsi qu’un échantillonnage de rejet afin d’améliorer la lisibilité et la sécurité du modèle.

L’autre rôle se situe au niveau du cadre des agents, où des méthodes inspirées de l’apprentissage par renforcement peuvent aider à acquérir des compétences. Un agent pourrait enregistrer les trajectoires de ses actions (quels outils ont été utilisés, quels résultats ont été obtenus) et les fournir à un apprentissage par renforcement hors ligne ou à un apprentissage par imitation afin d’identifier des procédures reproductibles. En analysant les succès et les échecs passés, il pourrait compresser les séquences d’outils fréquemment répétées en routines de niveau supérieur. Ces routines, écrites sous forme de fichiers de script ou de documents Markdown contenant des instructions, peuvent être révélées progressivement à l’agent pour des tâches ultérieures. Le système acquiert ainsi une forme d’apprentissage continu : face à quelque chose de nouveau, il apprend une compétence sur le moment et la stocke sous forme de module.

Comment est construite la bibliothèque DeepAgents

La bibliothèque DeepAgents de LangChain transforme ces idées en un outil conçu pour un usage en production, dont l’architecture est inspirée d’agents à plusieurs étapes tels que Claude Code et Manus.

• Planification avec write_todos. Un outil intégré permet à l’agent d’élaborer une liste étape par étape avant d’agir. Cette liste guide les actions et peut être modifiée à mesure que de nouvelles informations arrivent.
• Système de fichiers et mémoire. Les outils de fichiers (ls, read_file, write_file, edit_file) permettent à l’agent d’enregistrer le contexte dans des fichiers ou des bases de données. Le stockage des résultats intermédiaires et des notes évite la surcharge de la fenêtre de contexte et lui permet de revenir sur des étapes précédentes. Un backend adaptable, qu’il s’agisse de mémoire vive, d’un disque local, d’un stockage cloud ou d’un environnement isolé, gère la persistance et l’exécution sécurisée du code.

Sous-agents. Un outil task intégré crée des assistants spécialisés, tels qu’un sous-agent de recherche ou un sous-agent de critique. Chacun fonctionne dans son propre contexte, ce qui permet de garder l’agent principal organisé, et peut disposer de son propre prompt système et de ses propres outils. L’agent principal peut confier des recherches sur le Web ou des analyses de code pour recevoir des résumés en retour. Un sous-agent polyvalent se contente de reproduire la configuration de l’agent principal lorsque seul l’isolement est souhaité.

Compétences. Une compétence est un dossier contenant un SKILL.md et, éventuellement, des scripts ou des documents. Les compétences diffèrent des outils car elles ne sont pas chargées intégralement dans la demande. Seul le frontmatter YAML (nom, description, étiquettes) entre dans le contexte, tandis que les instructions complètes sont révélées progressivement lorsque l’agent juge qu’elles sont pertinentes. Cela réduit fortement l’utilisation de tokens. Une compétence PDF peut inclure un long tutoriel que l’agent ne lit que lorsque la tâche de l’utilisateur concerne des PDF. Les compétences permettent de diffuser les connaissances et les procédures sectorielles entre les agents, et ces derniers peuvent même écrire de nouvelles définitions de compétences au fur et à mesure qu’ils rencontrent de nouvelles tâches.

Grâce à cette conception, les agents avancés performent bien mieux que les agents simples sur des problèmes complexes à plusieurs étapes. Ils planifient à l’avance, utilisent la mémoire, apprennent de leur expérience et gèrent de grands contextes. Les rapports du secteur indiquent que les tâches confiées aux agents deviennent de plus en plus complexes, leur longueur doublant approximativement tous les quelques mois, ce qui est précisément le domaine où ces fonctionnalités sont essentielles. On passe ainsi de la réponse à des requêtes isolées à la résolution autonome de problèmes.

Une construction étape par étape

Le plan présenté ci-dessous combine l’architecture des agents avec, là où cela est pertinent, des idées issues de l’apprentissage par renforcement. Il utilise Python ainsi que le SDK DeepAgents. Commencez par installer les bibliothèques et configurer l’environnement :

# Install deepagents and necessary tools
!pip install --upgrade deepagents langchain tavily-python

# Import libraries and set API keys (e.g., for LLM and search tool)
import os
from getpass import getpass
os.environ["OPENAI_API_KEY"] = getpass("OpenAI API Key: ")
os.environ["TAVILY_API_KEY"] = getpass("Tavily API Key: ")

from deepagents import create_deep_agent
from deepagents.backends import FilesystemBackend
from deepagents.middleware.filesystem import FileData
from langchain.chat_models import init_chat_model
from tavily import TavilyClient

Définition de l’agent et de ses compétences

Viennent ensuite les agents avancés, dotés de leurs outils ainsi que de compétences prédéfinies. Pour un environnement de production, un backend fiable, comme le disque local ou LangGraph, est une meilleure option que la mémoire éphémère. Cette version utilise un FilesystemBackend basé dans le répertoire courant, qui charge les dossiers contenant les compétences :

from deepagents import create_deep_agent

# Assume we have local skill directories under "./skills"
skill_dirs = ["./skills/pdf_processing", "./skills/data_analysis"]

agent = create_deep_agent(
    model=model,
    system_prompt="""
You are a highly capable AI assistant. Your objectives:
1. Break tasks into steps using write_todos().
2. Use internet_search and file tools to gather and store information.
3. When given a task, plan and execute it step-by-step, writing to files as needed.
4. Load skills from the filesystem to handle specialized tasks when relevant.
5. Summarize results and refine final output before returning.
""",
    tools=[internet_search],             # Web search tool
    backend=FilesystemBackend(root_dir="./workspace"),  # Persistent file storage
    skills=skill_dirs,                  # Load skills from local directories
)

Le prompt du système met l’accent sur la planification et l’utilisation des compétences. Le paramètre skills fait référence à des dossiers dont les sous-dossiers contiennent chacun un SKILL.md ainsi que des fichiers de soutien. Par exemple, ./skills/pdf_processing/SKILL.md pourrait enseigner à l’agent comment parser des PDF. Lorsque les compétences sont chargées de cette manière, l’agent ne voit au début que des noms et des descriptions. Lorsque la tâche d’un utilisateur implique des PDF, il lit le SKILL.md correspondant ainsi que tous les fichiers référencés pour apprendre la procédure.

Un exemple de structure :

skills/
├── pdf_processing/
│   └── SKILL.md
└── data_analysis/
    ├── SKILL.md
    └── analysis_script.py

Et un éventuel pdf_processing/SKILL.md :

---
name: pdf-processing
description: Skill to extract and analyze content from PDF documents.
---
# PDF Processing Skill

To use this skill, follow these steps:
1. Use `pdf-tools` to read PDF content.
2. Summarize key findings from the PDF text.

...

Les instructions complètes ne sont lues que si l’agent décide que la demande actuelle concerne des PDF. C’est là l’application de la divulgation progressive : de gros fichiers de compétences ne gonflent pas chaque demande.

À quoi ressemble une exécution

Donnez maintenant à l’agent une tâche complexe. La demande initiale l’incite d’abord à élaborer un plan.

from langchain.schema import HumanMessage

query = "Organize the latest quarterly sales data and write a summary report."
response = agent.invoke({
    "messages": [HumanMessage(content=query)]
})
print(response["messages"][-1]["content"])

Conceptuellement, l’agent fera probablement ce qui suit :

1. Appeler write_todos() pour générer une liste de contrôle, par exemple charger le fichier des ventes, créer des graphiques, calculer des totaux et écrire le rapport.
2. Effectuer des appels d’outils, en utilisant internet_search ou des lectures de fichiers intégrées pour collecter des données existantes.
3. Transférer éventuellement le nettoyage ou l’analyse à un sous-agent lorsque la tâche nécessite une procédure spécialisée.
4. Utiliser des compétences. S’il existe une compétence en analyse de données, il pourra lire SKILL.md situé dans ./skills/data_analysis et la suivre.
5. Enregistrer les artefacts intermédiaires tels que les ensembles de données nettoyés ou les graphiques dans le système de fichiers.
6. Rédiger et affiner le résumé final.

Une exécution complète fait appel à des LLM distants, donc la vérification consiste principalement à s’assurer que la structure est correcte. Le code choisit un backend fiable, encadre les étapes à risque avec try/except (une version complète doit gérer les erreurs API et de fichiers) et peut être étendu avec un middleware de journalisation. Des tests unitaires pour chaque outil, avec des réponses de LLM simulées, permettraient de le valider.

Testage et évaluation

Les workflows d’agent sont évalués principalement par jugement. On vérifie si l’agent termine les tâches correctement et respecte son plan. Une approche consiste à utiliser des tâches synthétiques aux réponses connues : on lui donne un petit exercice de mathématiques et on compare le rapport final à la solution. Les métriques automatisées sont également utiles, comme le taux de réussite des tâches (chaque étape a-t-elle été accomplie) ou la similarité avec une réponse de référence évaluée par un juge LLM. Le texte libre pourrait encore nécessiter une révision humaine ou une critique basée sur un modèle pour la décision finale.

Si l’apprentissage par renforcement est utilisé pour l’acquisition de compétences, les progrès peuvent être mesurés à l’aide de courbes de récompense. Créez un environnement dans lequel l’achèvement des sous-tâches rapporte une récompense, et tracez la récompense totale par épisode, en utilisant éventuellement OpenAI Gym ou une configuration personnalisée. Les indicateurs importants sont l’efficacité des échantillons (vitesse à laquelle l’apprentissage converge), les performances finales et la stabilité avec différentes valeurs aléatoires de départ. En pratique, vous exécuterez également une série de tâches relevant de la recherche, du codage et de l’analyse, en enregistrant le taux de réussite et l’utilisation des tokens pour chacune d’elles.

L’observabilité est essentielle en environnement de production. Équipez l’agent de fonctionnalités de suivi et d’enregistrement des logs, car LangSmith peut capturer chaque appel à une outil ainsi que la réponse du LLM. Dans un système déployé, les logs peuvent être acheminés vers CloudWatch ou Prometheus, y incluant le nombre d’étapes, la latence par appel et les erreurs. Pour les composants d’apprentissage par renforcement, enregistrez l’historique des récompenses, les courbes de perte et les hyperparamètres. Les tests de charge avec de grands lots, de longues sessions et des entrées inhabituelles aident à vérifier la stabilité.

Déploiement en tant que service

Dans un déploiement réel, l’agent fonctionne en tant que microservice. Une architecture scalable ressemble à ceci :

+------------------+      +--------------+
|  Client/User     | <--> | API Gateway  | <---> [HTTP requests]
+------------------+      +------+-------+
                              |
                              v
                       +-------------+
                       |  AgentCore  |   <-- AWS Bedrock AgentCore (managed runtime)
                       +-------------+
                              |
                +-------------+-------------+
                |                           |
      +-------------------+       +-------------------+
      | Deep Agent Service |       | Storage (S3/DB)   |  <-- File/memory backend, logs
      +-------------------+       +-------------------+
                |                           |
                +-------------+-------------+
                              |
                      +---------------+
                      |   LLM Models  |  <-- e.g., OpenAI, Anthropic, local LLMs
                      +---------------+

Un agent de service sur AWS AgentCore ou un système similaire reçoit les instructions, coordonne les sous-agents et effectue des appels à des outils, chaque interaction étant enregistrée dans un stockage persistant afin d’assurer la traçabilité et la mémoire. Plusieurs aspects de conception se distinguent.

• Échelle et fiabilité. Exécutez l’agent dans un environnement sans serveur ou containerisé tel que AWS Bedrock AgentCore, Azure AI Agent Service ou Kubernetes. Il s’adapte à la charge en lançant de nouvelles instances pour chaque demande, et chaque session peut se dérouler dans sa propre micro-VM. Un backend persistant (S3, une base de données ou le stockage LangGraph) conserve l’état et la mémoire entre les redémarrages.
• Observabilité. Suivez chaque appel. Sur AWS, le kit de démarrage Bedrock AgentCore relie CloudWatch et X-Ray pour surveiller la latence et les pannes. Le fait de logger les hachages des prompts et des réponses au lieu des données sensibles brutes vous permet tout de même de suivre les performances, ainsi que l’utilisation des tokens, le nombre d’appels API et les taux de réussite.
• Sécurité. Restreignez ce que l’agent peut modifier. Les outils de système de fichiers ne doivent fonctionner qu’à l’intérieur de dossiers désignés, et l’exécution de code via le backend sandbox doit avoir lieu dans des environnements sécurisés tels que Modal ou Daytona. Accordez aux ressources cloud que l’agent utilise des rôles IAM à privilèges limités, et ajoutez une validation des entrées ainsi qu’un filtrage du contenu grâce à des vérifications de sécurité des LLM contre les prompts malveillants.
• Coût. Équilibrez les choix entre le modèle et l’architecture backend. Un modèle Anthropic moins cher peut gérer les tâches routinières, tandis qu’un modèle premium comme GPT-4o est réservé aux étapes de planification cruciales. En transférant le contexte en mémoire et en réutilisant les résultats des outils, on réduit le nombre de tokens de demande répétés.

Un exemple complet

Cet exemple en Python met en œuvre le plan, avec un traitement des erreurs et des commentaires. Il s’agit d’un exemple conceptuel qui nécessite des clés API réelles ainsi qu’un environnement pour fonctionner.

from deepagents import create_deep_agent
from deepagents.backends import FilesystemBackend
from deepagents.middleware.filesystem import FileData
from langchain.chat_models import init_chat_model
from tavily import TavilyClient
import os

def setup_agent():
    """Initialize the Deep Agent with tools, skills, and system prompt."""
    # Model and tools initialization
    model = init_chat_model(model="openai:gpt-4o")
    tavily_client = TavilyClient(api_key=os.environ["TAVILY_API_KEY"])
    def web_search(query: str, max_results: int = 3) -> str:
        results = tavily_client.search(query, max_results=max_results)
        return "\n".join(f"{r.title}: {r.summary}" for r in results)

    # Create the deep agent with planning, files, and skills
    try:
        agent = create_deep_agent(
            model=model,
            tools=[web_search],
            system_prompt="""You are an expert agent. Your workflow:
            1. Create a plan with write_todos().
            2. Use tools (e.g. web_search) and file system to research and work.
            3. If specialized tasks arise, load relevant skills from the 'skills' directory.
            4. Save results and refine the output at each step.
            """,
            backend=FilesystemBackend(root_dir="./workspace"),
            skills=["./skills/pdf_processing", "./skills/data_analysis"]
        )
        return agent
    except Exception as e:
        print(f"Error initializing agent: {e}")
        raise

def invoke_agent(agent, user_query):
    """Invoke the agent on a user query and return the final answer."""
    try:
        messages = [{"role": "user", "content": user_query}]
        result = agent.invoke({"messages": messages})
        return result["messages"][-1]["content"]
    except Exception as e:
        print(f"Agent invocation failed: {e}")
        return None

# Example usage
if __name__ == "__main__":
    agent = setup_agent()
    task = "Analyze the recent research on climate change and summarize key findings."
    answer = invoke_agent(agent, task)
    print("Agent response:", answer)

La création et l’invoque de l’agent se font au sein de fonctions dotées de docstrings ainsi que de blocs try/except. L’outil web_search utilise Tavily pour obtenir des données externes, et le prompt système indique à l’agent de planifier, d’utiliser des compétences et d’améliorer son résultat. Une version en production vérifierait les cas limites tels que des résultats de recherche vides ou des temps d’attente dépassés par l’API, et enregistrerait les détails des exceptions au lieu de les afficher. Les secrets doivent être stockés dans un environnement sécurisé, et non dans le code source. La structure s’étend naturellement avec l’ajout de plus d’outils ou de sous-agents.

Pour le valider correctement, écrivez des tests unitaires. Simulez le LLM pour qu’il renvoie un résultat de planification fixe, et vérifiez que l’agent crée les fichiers attendus ou appelle les outils dans le bon ordre. Mesurez également le temps de traitement et le coût en tokens sur des tâches de référence.

Compromis à prendre en compte

Les agents avancés combinent la planification, la mémoire, la délégation de tâches à des sous-agents ainsi que des compétences chargables pour gérer des missions à plusieurs étapes que les chatbots simples ne peuvent pas accomplir. Un prompt système clair, un flux de travail axé sur la planification et un ensemble d’outils riches fournissent une base solide pour des assistants autonomes. Les compétences contiennent des connaissances modulaires, comme pdf-processing ou deploy-to-prod, chargées sur demande afin que le contexte reste léger et que l’agent puisse continuer à apprendre.

• Exactitude par rapport au coût. Des modèles puissants tels que GPT-4o ou Claude Sonnet, associés à des recherches approfondies, améliorent l’exactitude mais augmentent les frais liés aux tokens et aux API. Le mélange de tailles de modèles et le stockage en cache aident à équilibrer qualité et coût.
• Éscalabilité face à la complexité. Un environnement d’exécution d’agent sans serveur comme AWS AgentCore permet l’auto-échellement et l’observabilité, mais cela nécessite des travaux d’intégration : containerisation du code de l’agent et configuration du réseau.

Sécurité face à la flexibilité. L’exécution dans un environnement isolé via des blocs Modal ou similaires limite les risques d’injection de code, mais elle restreint également des opérations telles que les appels réseau arbitraires. Définissez des interfaces d’outil claires en fonction des besoins.

Fiableté. Réessayez les erreurs temporaires comme les temps d’attente des LLM, et envisagez des points de contrôle humains pour les étapes critiques, puisque certains frameworks d’agents prennent en charge les interruptions.

Observabilité. LangSmith ou un enregistrement personnalisé permet de tracer chaque étape de planification et chaque appel à un outil. Surveillez la consommation de CPU, de GPU et la latence, et vérifiez constamment la qualité des résultats.

À l’avenir, l’acquisition de compétences pourrait elle-même être automatisée : l’apprentissage par renforcement ou l’apprentissage non supervisé à partir de trajectoires passées pourraient générer de nouvelles définitions de compétences. Des frameworks multi-agents tels que Microsoft AutoGen ou Salesforce AgentForce pourraient coordonner plusieurs agents spécialisés qui communiquent via des protocoles LangGraph.

Créer un agent capable d’apprendre des compétences nécessite deux éléments : la bonne pile logicielle et, si souhaité, des techniques d’apprentissage par renforcement qui l’améliorent au fil du temps. Grâce à DeepAgents et à une ingénierie rigoureuse, on peut mettre en place des assistants capables de résoudre des problèmes complexes seuls, d’apprendre de nouvelles procédures et de fonctionner de manière fiable à grande échelle.