Обучение Deep Agents новым навыкам: планирование, сабагенты и файлы SKILL.md

Агентные ИИ — это системы, состоящие из нескольких взаимодействующих агентов, которые делят сложную, запутанную задачу, обмениваются информацией и действуют как небольшая команда специалистов. Одинокий чат-бот отвечает на один вопрос. Агентной системе для выполнения задачи на нескольких этапах необходимы планирование, память и возможность использования инструментов. Метод подкрепления (Reinforcement Learning, RL) представляет собой классический подход к созданию агентов, учащихся на основе проб и ошибок: глубокая сеть наблюдает за окружающей средой, выбирает действия, такие как вызов инструментов или выполнение кода, и получает награды, которые направляют её поведение. Глубокое обучение с подкреплением привело к сверхчеловеческим результатам в играх го и шахматы, а также к хорошим достижениям в робототехнике, всё это благодаря максимизации ожидаемой суммарной награды. Применение этих идей к агентам, основанным на больших языковых моделях, открывает интересную возможность — а именно создание агентов, способных использовать повторно применимые алгоритмы или навыки, что позволяет им планировать и выполнять действия с меньшими усилиями.

Что делает агента «глубоким»?

Глубокие агенты расширяют возможности помощника на основе LLM четырьмя функциями:

1. Инструмент планирования, разделяющий сложные задачи на этапы.
2. Подагенты для параллельной работы и изоляции контекста.
3. Постоянная файловая система, выполняющая функцию памяти.
4. Подробный системный промпт с указанием целей и ограничений.

Все это позволяет агенту планировать, сохранять состояние и выполнять сложные рабочие процессы, не перегружая контекст промпта. Поверхностный чат-бот отвечает один раз. Глубокий агент работает циклически: он планирует, ищет информацию, сохраняет результаты, синтезирует и улучшает ответы. При запросе на отчет он может составить список дел, выполнить поиск в Интернете или анализ, сохранить заметки в файлах, затем подготовить и отредактировать проект, причем весь процесс контролируется моделью без участия человека.

Обучение с подкреплением и источник навыков

Рекуррентное обучение является основой для агентов, которые учатся путем действий. Агент наблюдает состояние, совершает действие и получает награду или штраф, после чего, максимизируя ожидаемую сумму будущих наград, улучшает свою стратегию. Оно отличается от обучения с учителем, в котором присутствуют метки, и от обучения без учителя, направленного на поиск скрытой структуры, поскольку работает с последовательными решениями в условиях неопределенности. В глубоком рекуррентном обучении в качестве аппроксиматоров функций используются нейронные сети, что позволяет обрабатывать изображения, текст и сырые данные сенсоров. К известным этапам развития относятся глубокие сети Q для Atari, а также методы градиента стратегии, такие как PPO и A2C, применяемые для управления в непрерывных и стратегических играх. В более новых исследованиях рассматривается иерархическое обучение навыкам, при котором агенты находят варианты действий — действия, распространенные во времени и решающие подзадачи, что способствует исследованию и переносу знаний.

Для агентов на основе больших языковых моделей рекуррентное обучение выполняет две функции. Первая — тонкая настройка самой модели с использованием сигналов обратной связи. Например, метод RLHF позволяет сделать модели более безопасными и более соответствующими теме. DeepSeek-R1 показал, что чистое рекуррентное обучение без маркированных данных может обучить модель рассуждений, способную конкурировать с лучшими системами в математике и программировании: модель генерирует несколько ответов, автоматический оценщик ставит баллы за правильные ответы и штрафует остальные, и за множество раундов алгоритм вроде PPO улучшает стратегию модели. В реальных системах могут применяться дополнительные методы, такие как контролируемая тонкая настройка и выборка отклонений, для повышения читаемости и безопасности.

Другая роль находится на уровне фреймворка агентов, где методы, вдохновлённые методами рекуррентного обучения, могут помочь в освоении навыков. Агент может записывать траектории своих действий (какие инструменты использовались, какой результат получен) и передавать их в системы оффлайн-рекуррентного обучения или обучения путём имитации для выявления повторяемых процедур. Анализируя прошлые успехи и неудачи, он может сжимать часто повторяющиеся последовательности действий с использованием инструментов в более высокоуровневые рутины. Эти рутины, записанные в виде файлов с скриптами или инструкций в формате Markdown, могут постепенно раскрываться агенту при выполнении последующих задач. Таким образом система обретает возможность непрерывного обучения: сталкиваясь с чем-то новым, она учится осваивать навыки «на лету» и сохраняет их в виде модулей.

Как построена библиотека DeepAgents

Библиотека DeepAgents от LangChain превращает эти идеи в готовое решение для практического использования, её архитектура разработана с учётом многоэтапных агентов вроде Claude Code и Manus.

• Планирование с помощью write_todos. Встроенный инструмент позволяет агенту составить пошаговый список перед выполнением действий. Этот список направляет работу и может изменяться по мере поступления новой информации.
• Файловая система и память. Инструменты для работы с файлами (ls, read_file, write_file, edit_file) позволяют агенту сохранять контекст в файлах или базах данных. Хранение промежуточных результатов и заметок предотвращает переполнение окна контекста и позволяет возвращаться к предыдущим шагам. Поддерживаемый модуль хранения, будь то память, локальный диск, облачное хранилище или изолированная среда, обеспечивает сохранность данных и безопасную экспекуцию кода.

Подагенты. Встроенный инструмент task создаёт специализированных помощников, таких как подагент для исследований или подагент для критики. Каждый из них работает в собственном контексте, что позволяет основному агенту оставаться чистым от лишних данных, и может иметь собственные системные указания и инструменты. Основной агент может поручить им поиск информации в Интернете или анализ кода и получить возвращаемые ими краткие отчёты. Подагент универсального назначения просто воспроизводит настройки основного агента, когда требуется лишь изоляция.

Навыки. Навык — это папка, содержащая файл SKILL.md, а также, по желанию, скрипты или документы. Навыки отличаются от инструментов тем, что они не загружаются полностью в промпт. В контекст попадает только YAML-метаинформация (название, описание, теги), а полные инструкции раскрываются постепенно, когда агент считает их релевантными. Это значительно сокращает использование токенов. Навык в формате PDF может включать длинное руководство, которое агент читает только тогда, когда задача пользователя связана с PDF-файлами. Навыки позволяют распространять знания и процедуры в разных агентах, причем агенты могут даже создавать новые определения навыков при решении новых задач.

Благодаря такой архитектуре глубокие агенты демонстрируют значительно лучшие результаты, чем поверхностные, при решении длинных многоэтапных задач. Они планируют действия заранее, используют память, учатся на опыте и справляются с большими объемами информации. В отчетах отрасли отмечается, что задачи для агентов становятся все более сложными — их длина примерно удваивается каждые несколько месяцев, и именно здесь критически важны эти функции. Происходит сдвиг от ответов на изолированные запросы к автономному решению проблем.

Пошаговая разработка

Приведенный ниже план сочетает архитектуру агента с идеями машинного обучения там, где это целесообразно. Для его реализации используются Python и SDK DeepAgents. Начните с установки необходимых библиотек и настройки среды:

# 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

Определение агента и его навыков

Далее рассматривается «глубокий» агент с его инструментами и заранее определёнными навыками. Для производственного использования более подходящим выбором, чем временная память, является надёжный бэкенд, такой как локальный диск или LangGraph. В этой версии используется FilesystemBackend, расположенный в текущей директории, который загружает папки с навыками:

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
)

В промпте системы подчеркивается важность планирования и использования навыков. Параметр skills указывает на директории, в подпапках которых находятся файлы SKILL.md вместе с вспомогательными документами. Например, файл ./skills/pdf_processing/SKILL.md может научить агента, как парсить PDF-файлы. После загрузки таких навыков агент изначально видит только их названия и описания. Когда задача пользователя связана с PDF-файлами, агент читает соответствующий файл SKILL.md и все упомянутые в нем файлы, чтобы изучить процедуру выполнения задачи.

Пример структуры:

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

И возможный вариант 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.

...

Полные инструкции читаются только в том случае, если агент считает, что текущий запрос касается PDF-файлов. Это и есть принцип постепенного раскрытия информации: большие файлы с инструкциями не увеличивают объем каждого запроса.

Как выглядит выполнение задачи

Теперь дайте агенту сложную задачу. Первоначальный запрос побуждает его сначала составить план.

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"])

Концептуально агент, скорее всего, будет выполнять следующее:

1. Вызывать функцию write_todos() для создания списка задач, например, загружать файл с данными о продажах, генерировать графики, рассчитывать суммы и записывать отчет.
2. Выполнять запросы к инструментам с использованием internet_search или встроенных функций чтения файлов для сбора существующих данных.
3. В случае необходимости специализированных действий возможно передать задачи по очистке или анализу дочернему агенту.
4. Использовать имеющиеся навыки. Если существует навык анализа данных, агент может прочитать файл SKILL.md из папки ./skills/data_analysis и следовать его инструкциям.
5. Сохранять промежуточные результаты, такие как очищенные наборы данных или графики, в файловой системе.
6. Написать и доработать окончательный отчет.

Полная обработка задачи влечёт за собой вызов удалённых больших языковых моделей, поэтому проверка здесь в основном касается правильности структуры. Код выбирает надёжный бэкенд, оборачивает рискованные операции в блоки try/except (полная версия должна перехватывать ошибки API и файлов), и его можно расширить с помощью промежуточных компонентов для логирования. Единичные тесты для каждого инструмента с имитацией ответов больших языковых моделей позволят их проверить.

Тестирование и оценка

Рабочие процессы агентов оцениваются в основном на основе суждения. Основной критерий — правильное выполнение задач агентом и соблюдение им своего плана. Один из подходов предусматривает использование синтетических задач с известными ответами: даётся небольшая математическая задача, и финальный отчёт сравнивается с решением. Также помогают автоматизированные показатели, такие как процент успешного выполнения задач (был ли завершён каждый шаг) или степень сходства с эталонным ответом, оценённая большой языковой моделью-судьёй. Для текстов свободной формы всё равно может потребоваться человеческий анализ или оценка на основе модели перед окончательным выводом.

Если для обучения навыкам используется RL, прогресс можно измерять с помощью кривых наград. Создайте среду, в которой выполнение подзадач приносит награду, и отобразите общую сумму наград за каждую эпизоду, возможно, с использованием OpenAI Gym или собственной настройки. Важными показателями являются эффективность обучения (скорость сходимости), конечная производительность и стабильность при разных начальных условиях. На практике также следует выполнить набор задач в областях исследований, программирования и анализа, отслеживая для каждой из них процент успеха и количество используемых токенов.

В условиях производственной среды наблюдаемость имеет решающее значение. Оснастите агента инструментами для трейсинга и логгинга, поскольку LangSmith может фиксировать каждый вызов инструмента и ответ ЯИ. В развернутой системе логи могут передаваться в CloudWatch или Prometheus с информацией о количестве шагов, задержке за каждый вызов и ошибках. Для компонентов на основе RL записывайте историю наград, кривые потерь и гиперпараметры. Тесты на нагрузку с большими объемами данных, длительными сессиями и нестандартными входными данными помогают подтвердить стабильность.

Развертывание в виде сервиса

При реальном развертывании агент работает в качестве микросервиса. Масштабируемая архитектура выглядит следующим образом:

+------------------+      +--------------+
|  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
                      +---------------+

Служба агентов на AWS AgentCore или аналогичных платформах принимает команды, координирует действия субагентов и выполняет вызовы инструментов; каждое взаимодействие записывается в постоянно хранимом хранилище для обеспечения возможности отслеживания и сохранения информации. Особого внимания заслуживают несколько аспектов проектирования.

• Масштабируемость и надежность. Агент может работать в безсерверной или контейнеризованной среде, такой как AWS Bedrock AgentCore, Azure AI Agent Service или Kubernetes. Он масштабируется в зависимости от нагрузки, запуская новые экземпляры по каждому запросу, причем каждая сессия может проходить в собственной микро-ВМ. Постоянное хранилище на стороне сервера (S3, база данных или хранилище LangGraph) сохраняет состояние и информацию между перезагрузками.
• Наблюдаемость. Отслеживайте каждый вызов. В AWS стартовый набор Bedrock AgentCore объединяет CloudWatch и X-Ray для мониторинга задержек и сбоев. Хранение хэшей вводных данных и ответов вместо самих чувствительных данных позволяет отслеживать производительность, а также использование токенов, количество вызовов API и коэффициенты успеха.
• Безопасность. Ограничьте возможности агента. Инструменты файловой системы должны работать только в определённых каталогах, а выполнение кода в режиме sandbox должно происходить в защищённых средах, таких как Modal или Daytona. Предоставляйте любым облачным ресурсам, с которыми взаимодействует агент, роли IAM с минимальными привилегиями, а также добавляйте проверку входных данных и фильтрацию контента с использованием механизмов безопасности LLM для защиты от злонамеренных запросов.
• Стоимость. Необходимо сбалансировать выбор модели и технологий на стороне сервера. Более дешевая модель Anthropic может обрабатывать рутинные задачи, в то время как премиум-модель вроде GPT-4o используется для важных этапов планирования. Перенос контекста в память и повторное использование результатов инструментов сокращает количество повторяющихся токенов запроса.

Полный пример

В этом примере на Python реализован план с обработкой ошибок и комментариями. Это концептуальная версия, ей требуются реальные API-ключи и среда для запуска.

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)

Создание и вызов агента осуществляются с помощью функций с описаниями и блоками try/except. Инструмент web_search использует Tavily для получения внешних данных, а системное указание предписывает агенту планировать действия, применять необходимые навыки и улучшать качество вывода. В производственной версии необходимо учитывать крайние случаи, такие как отсутствие результатов поиска или превышение времени ожидания от API, а также записывать детали исключений вместо их вывода на экран. Конфиденциальные данные должны храниться в защищённой среде, а не в исходном коде. Структура может быть легко расширена путём добавления новых инструментов или подагентов.

Чтобы правильно проверить работу системы, необходимо написать тесты на единицы. Необходимо имитировать поведение большой языковой модели с помощью моков, чтобы она возвращала фиксированный результат планирования, и проверять, что агент создаёт ожидаемые файлы или вызывает инструменты в правильном порядке. Также следует измерять время обработки запросов и стоимость токенов на тестовых задачах.

Факторы, которые необходимо учитывать при планировании

Продвинутые агенты объединяют в себе функции планирования, хранения информации, делегирования задач подагентам и использования загружаемых навыков для выполнения многоэтапных задач, с которыми не справятся простые чат-боты. Четкое системное указание, работа по принципу планирования в первую очередь и богатый набор инструментов обеспечивают прочную основу для автономных помощников. Навыки содержат модульные знания, такие как pdf-processing или deploy-to-prod, которые загружаются по мере необходимости, чтобы контекст оставался лаконичным, а агент мог продолжать обучаться.

• Корректность при соблюдении бюджета. Мощные модели, такие как GPT-4o или Claude Sonnet, наряду с обширными поисками, повышают точность, но увеличивают расходы на токены и API. Сочетание разных размеров моделей и кэширование помогает сбалансировать качество и стоимость.
• Масштабируемость при росте сложности. Сервисы без серверов, такие как AWS AgentCore, обеспечивают автомасштабирование и возможности мониторинга, однако требуют дополнительной настройки: контейнеризация кода агента и настройка сетевых связей.

Безопасность при сохранении гибкости. Выполнение в изолированной среде с использованием модальных или аналогичных блоков снижает риски внедрения кода, однако ограничивает такие операции, как произвольные сетевые запросы. Необходимо определить четкие интерфейсы инструментов для выполнения конкретных задач.

Надежность. Следует повторять попытки выполнения при временных ошибках, таких как превышение времени ожидания от LLM, а также учитывать возможность вмешательства человека на критических этапах, поскольку некоторые фреймворки агентов поддерживают прерывания.

Возможность наблюдения. Инструменты вроде LangSmith или пользовательские механизмы логирования позволяют отслеживать каждый шаг планирования и вызов инструментов. Необходимо контролировать загрузку CPU и GPU, время отклика, а также постоянно проверять качество результата.

В будущем сам процесс приобретения навыков может быть автоматизирован: методы рекуррентного обучения или обучения без учителя на основе прошлых данных могут генерировать новые определения навыков. Фреймворки с несколькими агентами, такие как Microsoft AutoGen или Salesforce AgentForce, могут координировать действия нескольких специализированных агентов через протоколы LangGraph.

Для создания агента, способного осваивать навыки, необходимы два элемента: подходящий набор программного обеспечения и, при необходимости, методы рекуррентного обучения, позволяющие с течением времени улучшать его функции. Благодаря технологии DeepAgents и строгому подходу к инженерии можно создавать ассистентов, которые сами решают сложные задачи, учатся новым процедурам и надежно работают в крупном масштабе.