Большинство команд до сих пор вручную собирают агентные циклы в LangGraph. Deep Agents предлагает более высокоуровневый подход — и он значительно категоричнее в своих решениях, чем можно ожидать.
Есть паттерн, который встречается почти в каждой команде, серьёзно берущейся за разработку агентов.
Сначала пробуют цепочки LangChain. Для простых пайплайнов они работают нормально. Но когда задача усложняется — требуются вызовы инструментов, циклы, обработка выходных данных переменной длины — цепочки перестают справляться. Тогда команды переходят к LangGraph и внезапно вынуждены писать схемы состояний, условные рёбра и логику компиляции графа ещё до того, как приступают к самой задаче.
LangGraph при этом не плох. Он очень мощный. Но это рантайм — низкоуровневый примитив. Большинство людей используют его как прикладной фреймворк. LangChain это осознал, и deepagents стал их ответом.
Что такое Deep Agents на самом деле
Будем конкретны: «deep agents» звучит расплывчато, будто может означать что угодно.
Deepagents — это отдельная Python-библиотека. Устанавливается через pip install deepagents и работает поверх LangChain и LangGraph. В документации её называют «agent harness» — оболочкой агента. Она предоставляет стандартный цикл вызова инструментов, но с набором встроенных возможностей из коробки, которые не нужно изобретать заново.
Центральная функция — create_deep_agent(). В простейшем виде достаточно одной строки:
Всё. Под капотом библиотека сама обрабатывает граф LangGraph, управление состоянием, стриминг и контроль контекстного окна. Вы не трогаете ни одной из этих систем напрямую.
Но настоящая ценность — в том, что идёт в комплекте по умолчанию.
Пять возможностей, которые отличают Deep Agents
1. Встроенное планирование через write_todos
Каждый deep agent автоматически имеет доступ к инструменту write_todos. При получении сложной задачи агент использует его, чтобы разбить работу на отдельные шаги, отслеживать их статусы (pending, in_progress, completed) и адаптировать план по мере выполнения.
Это не просто промпт-трюк: список задач сохраняется в состоянии агента. Он может возвращаться к нему, обновлять и ссылаться на протяжении всей сессии. Структура планирования встроена в оболочку — вам не нужно вручную просить модель «думать шаг за шагом».
2. Виртуальная файловая система
Это то, что удивило больше всего. Deep agents поставляются с набором инструментов для работы с файловой системой: ls, read_file, write_file, edit_file, glob, grep.
Зачем агенту файловая система? Для управления контекстом.
Контекстные окна LLM ограничены. При длительных задачах история разговора быстро разрастается. Deep agents решают это, выгружая объёмный контент во встроенную виртуальную файловую систему вместо хранения всего в контексте.
Когда результат инструмента превышает 20 000 токенов, он автоматически сохраняется в настроенный бэкенд. В контексте остаётся только ссылка на файл и превью из 10 строк. Агент может позже прочитать файл через read_file или найти нужное через grep.
Это интеллектуальная компрессия: не обрезка, не чанкинг, а целенаправленная выгрузка с извлечением по запросу.
Файловая система поддерживает in-memory состояние (по умолчанию), локальный диск, LangGraph Store для межпоточного хранения или изолированные среды вроде Modal и Daytona. Бэкенд подключается как плагин.
3. Порождение субагентов
Оболочка включает встроенный инструмент task, позволяющий основному агенту порождать специализированных субагентов для изолированных подзадач.
Почему это важно. При долгой исследовательской задаче один агент может накопить в контексте промежуточные шаги, результаты поиска и частичные выводы. Субагенты решают эту проблему элегантно: основной агент делегирует подзадачу новому экземпляру агента с чистым контекстом. Тот работает автономно и возвращает только итоговое резюме. Контекст основного агента остаётся чистым.
Можно настроить собственных субагентов с их инструментами и системными промптами. Но универсальный субагент с доступом к файловой системе доступен по умолчанию — без дополнительной настройки.
4. Автоматическая компрессия и суммаризация контекста
Здесь библиотека по-настоящему отрабатывает свою ценность на длительных задачах.
Когда контекст достигает 85% лимита модели, а выгружать в файловую систему уже нечего, оболочка запускает автоматическую суммаризацию. LLM генерирует структурированное резюме: намерение сессии, созданные артефакты, следующие шаги. Это резюме заменяет полную историю в рабочей памяти.
Оригинальные сообщения сохраняются в файловой системе как канонический архив. Агент может восстановить детали при необходимости.
В результате deep agents могут работать неограниченно долго на сложных задачах, не упираясь в лимиты контекста. С чистым LangGraph это пришлось бы проектировать вручную.
5. Долгосрочная память между разговорами
По умолчанию состояние агента живёт в рамках одного потока. Но при настройке CompositeBackend с LangGraph Store агент может сохранять память между сессиями и потоками.
Файлы по пути /memories/ (или другому настроенному пути) переживают перезапуски и доступны из любого потока. Так можно построить агента, который запоминает предпочтения, конвенции кодовой базы или прогресс многодневного проекта.
Как это вписывается в экосистему LangChain
Разберём по уровням.
LangChain — фреймворк, предоставляющий строительные блоки: модели, инструменты, промпты, цепочки. Это фундамент.
LangGraph — рантайм для устойчивого, стейтфул-выполнения агентов на основе графов. Он обеспечивает персистентность, стриминг, прерывания и сложные потоки. Это движок.
Deep Agents — оболочка, построенная поверх обоих. Она не заменяет LangGraph, а использует его под капотом. Что она даёт — высокоуровневый API с категоричными настройками по умолчанию, чтобы не проектировать планировщик, файловую систему, компрессию контекста и субагентов с нуля.
Можно думать так: LangGraph — двигатель и трансмиссия. Deep Agents — готовый автомобиль.
Для простых агентов create_agent из LangChain, скорее всего, достаточно. Для сложных, многошаговых задач с большими требованиями к контексту — именно тут deepagents оправдывает свою абстракцию.
Создание исследовательского агента: практический пример
Вот как работает исследовательский агент, способный искать в интернете и создавать структурированный отчёт:
- Агент вызывает
write_todos, чтобы спланировать этапы исследования - Запускает поиск, автоматически выгружая объёмные результаты в виртуальную файловую систему
- При необходимости порождает субагента для обработки конкретного раздела
- Считывает нужные файлы по мере необходимости и синтезирует итоговый отчёт
- На всём протяжении оболочка управляет контекстом, чтобы модель не упёрлась в лимит окна
Вы не написали ни строчки этой инфраструктуры. Она пришла вместе с оболочкой.
CLI Deep Agents
Deepagents также включает агент командной строки, построенный на том же SDK.
Это кодовый агент, запускаемый в терминале. По функционалу он близок к Claude Code или Aider, но построен на SDK Deep Agents. Поддерживает интерактивный режим, неинтерактивный режим (флаг -n для скриптинга), пользовательские навыки и постоянную память.
Можно обучить его конвенциям проекта — и он будет помнить их между сессиями.
Тот же SDK, который питает продакшн-агент для исследований, также даёт готовый рабочий инструмент для разработчика.
Когда стоит и не стоит использовать Deep Agents
Deepagents имеет смысл, когда:
- Задача требует планирования и нескольких шагов
- Результаты инструментов объёмны и требуют управления на протяжении сессии
- Нужно делегирование субагентам без ручной инфраструктуры
- Требуется постоянная память между потоками
- Вы строите кодового агента или автономную исследовательскую систему
Оставайтесь с create_agent из LangChain или чистым LangGraph, когда:
- Агент простой: один-два вызова инструментов, короткие ответы
- Нужен тонкий контроль над топологией графа
- Вы уже глубоко в кастомном LangGraph-пайплайне и не хотите категоричных настроек по умолчанию
Библиотека честно говорит об этом в документации: для простых агентов используйте простые инструменты.
Почему это важнее, чем очередной релиз фреймворка
Обратите внимание на тайминг.
Агентные системы находятся в точке перелома. Базовые паттерны — вызов инструментов, циклы ReAct, простой RAG — хорошо изучены. Сейчас индустрия работает над тем, как сделать агентов надёжными на длительных задачах: с планированием, большим контекстом, персистентностью и делегированием.
Каждая команда, строящая продакшн-агентов, вынуждена была изобретать решения этих задач с нуля. Стратегии управления контекстом, паттерны субагентов, архитектуры памяти — всё это повторяется в слегка разных формах по всей индустрии.
Deepagents — ставка LangChain на то, что эти решения достаточно типичны, чтобы их стандартизировать. Концепция «оболочки агента» — категоричные настройки по умолчанию, встроенная инфраструктура, подключаемые бэкенды — это попытка сместить фокус с «как построить водопровод?» на «что мы хотим, чтобы агент делал?».
Успех зависит от того, выдержат ли настройки по умолчанию продакшн. Но как направление проектирования — это правильный выбор.
Как начать работу
Полная документация, включая бэкенды, субагентов, песочницы, human-in-the-loop и CLI, доступна на docs.langchain.com/oss/python/deepagents.
Если вы сейчас строите что-то серьёзное на агентах, стоит потратить один вечер, чтобы понять, где deepagents вписывается в ваш стек — даже если вы не планируете использовать его немедленно.