Большинство команд до сих пор вручную собирают агентные циклы в LangGraph. Deep Agents предлагает более высокоуровневый подход, и он более категоричный в своих решениях, чем можно ожидать.

Есть паттерн, который я наблюдаю почти в каждой команде, которая серьёзно берётся за разработку агентов.

Сначала пробуют цепочки LangChain. Для простых пайплайнов работает нормально. Потом задача усложняется: нужны вызовы инструментов, циклы, обработка выходных данных переменной длины, и цепочки перестают справляться. Тогда берут LangGraph, и внезапно приходится писать схемы состояний, условные рёбра и логику компиляции графа ещё до того, как добрались до самой задачи.

LangGraph при этом не плох. Он очень мощный. Но это рантайм, низкоуровневый примитив, а большинство людей используют его так, будто это прикладной фреймворк. LangChain это заметил, и deepagents стал их ответом.

Что такое Deep Agents на самом деле

Буду конкретен, потому что «deep agents» звучит так, будто это может означать что угодно.

deepagents — это отдельная Python-библиотека. Устанавливается через pip install deepagents и работает поверх LangChain и LangGraph. В документации LangChain описывают её как «agent harness» (оболочку агента): она предоставляет тот же цикл вызова инструментов, что и другие фреймворки, но с набором встроенных возможностей из коробки, которые не нужно изобретать заново.

Центральная функция — create_deep_agent(). В простейшем виде:

from deepagents import create_deep_agent

def get_weather(city: str) -> str:
    """Get weather for a given city."""
    return f"It's always sunny in {city}!"

agent = create_deep_agent(
    tools=[get_weather],
    system_prompt="You are a helpful assistant",
)

agent.invoke(
    {"messages": [{"role": "user", "content": "What is the weather in Mumbai?"}]}
)

Всё. Одна функция. Под капотом библиотека обрабатывает граф 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, который позволяет основному агенту порождать специализированных субагентов для изолированных подзадач.

Почему это более существенно, чем кажется. При длительной исследовательской задаче, если один агент обрабатывает всё, его контекст заполняется промежуточными шагами, результатами поиска и частичными выводами. Субагенты решают эту проблему элегантно: основной агент делегирует конкретную подзадачу новому экземпляру агента со своим чистым контекстом. Субагент работает автономно, завершает свою работу и возвращает единственное резюме основному агенту. Контекст основного агента остаётся чистым.

Можно настроить собственных субагентов с их инструментами и системными промптами:

from deepagents import create_deep_agent, Subagent

code_reviewer = Subagent(
    name="code-reviewer",
    system_prompt="You are an expert code reviewer. Analyze code for bugs, style, and performance.",
    tools=[read_file_tool],
)

agent = create_deep_agent(
    tools=[internet_search],
    subagents=[code_reviewer],
    system_prompt="You are a research and engineering assistant.",
)

Субагент по умолчанию — универсальный, с инструментами файловой системы — доступен всегда без дополнительной настройки.

4. Автоматическая компрессия и суммаризация контекста

Вот тут библиотека по-настоящему отрабатывает свою ценность на длительных задачах.

Когда контекст агента достигает 85% лимита контекстного окна модели, и выгружать в файловую систему уже нечего, оболочка запускает автоматическую суммаризацию. LLM генерирует структурированное резюме всего, что произошло: намерение сессии, созданные артефакты, следующие шаги. Это резюме заменяет полную историю разговора в рабочей памяти. Оригинальные сообщения сохраняются в файловую систему как канонический архив, так что агент может восстановить конкретные детали при необходимости.

В результате deep agents могут работать неограниченно долго на сложных задачах, не упираясь в лимиты контекста. С чистым LangGraph это пришлось бы проектировать вручную.

5. Долгосрочная память между разговорами

По умолчанию состояние агента живёт внутри одного потока. Но при настройке CompositeBackend с LangGraph Store агент может сохранять память между сессиями и потоками.

Файлы, сохранённые по пути /memories/ (или где вы настроите), переживают перезапуски агента и доступны из любого потока разговора. Так можно построить агента, который запоминает ваши предпочтения, конвенции вашей кодовой базы или прогресс многодневного исследовательского проекта.

from deepagents import create_deep_agent
from deepagents.backends import CompositeBackend, StateBackend, StoreBackend
from langgraph.store.memory import InMemoryStore

store = InMemoryStore()
backend = CompositeBackend(
    routes={"/memories/": StoreBackend(store=store)},
    default=StateBackend(),
)

agent = create_deep_agent(
    tools=[...],
    backend=backend,
    memory=["path/to/AGENTS.md"],  # persistent context file
)

Как это вписывается в экосистему LangChain

Здесь часто возникает путаница, поэтому стоит разложить по полочкам.

LangChain — фреймворк, который предоставляет строительные блоки: модели, инструменты, промпты, цепочки. Это фундамент.

LangGraph — рантайм для устойчивого, стейтфул-выполнения агентов на основе графов. Он обрабатывает персистентность, стриминг, прерывания и сложные условные потоки. Это движок.

Deep Agents — оболочка, построенная поверх обоих. Она не заменяет LangGraph, а использует его под капотом для всего. Что она предоставляет — более высокоуровневый API с категоричными настройками по умолчанию, чтобы не пришлось строить планировщик, файловый слой, компрессию контекста и инфраструктуру субагентов с нуля каждый раз.

Можно думать об этом так: LangGraph даёт двигатель и трансмиссию. Deep Agents даёт автомобиль.

Для простых агентов create_agent из LangChain, скорее всего, достаточно. Для сложных, долгоиграющих, многошаговых задач с большими требованиями к контексту — именно тут deepagents оправдывает свою абстракцию.

Создание исследовательского агента: практический пример

Вот практический пример — исследовательский агент, который может искать в интернете и создавать структурированный отчёт:

import os
from typing import Literal
from tavily import TavilyClient
from deepagents import create_deep_agent

tavily_client = TavilyClient(api_key=os.environ["TAVILY_API_KEY"])

def internet_search(
    query: str,
    max_results: int = 5,
    topic: Literal["general", "news", "finance"] = "general",
    include_raw_content: bool = False,
):
    """Run a web search and return results."""
    return tavily_client.search(
        query,
        max_results=max_results,
        include_raw_content=include_raw_content,
        topic=topic,
    )

research_instructions = """You are an expert researcher. 
Your job is to conduct thorough research and then write a polished report.
Use internet_search to gather information.
Write your findings to files as you go to avoid losing context.
Use write_todos to plan your research steps before starting.
"""

agent = create_deep_agent(
    model="anthropic:claude-sonnet-4-6",  # default model
    tools=[internet_search],
    system_prompt=research_instructions,
)

result = agent.invoke({
    "messages": [{
        "role": "user",
        "content": "Research the current state of agentic AI frameworks in 2025 and write a structured report."
    }]
})

print(result["messages"][-1].content)

Что происходит при запуске:

  • Агент вызывает write_todos, чтобы спланировать этапы исследования

  • Запускает поиск, автоматически выгружая объёмные результаты в виртуальную файловую систему

  • Если задача сложная, порождает субагента для обработки конкретного раздела

  • Считывает нужные файлы по мере необходимости и синтезирует итоговый отчёт

  • На протяжении всего процесса оболочка управляет контекстом, чтобы модель никогда не упёрлась в лимит окна

Вы не написали ни строчки этой инфраструктуры. Она пришла вместе с оболочкой.

CLI Deep Agents

Ещё одна вещь, которую стоит знать: deepagents также поставляется с агентом командной строки, построенным на том же SDK.

pip install deepagents
deepagents  # запускает интерактивного CLI-агента

Это кодовый агент, который можно запустить в терминале. По аналогии с Claude Code или Aider, но построенный на SDK Deep Agents. Он поддерживает интерактивный режим, неинтерактивный конвейерный режим (флаг -n для скриптинга), пользовательские навыки и постоянную память. Можно обучить его конвенциям вашего проекта, и он будет помнить их между сессиями.

Это значит, что тот же SDK, который питает ваш продакшн-агент для исследований, также питает рабочий инструмент разработчика из коробки.

Когда стоит и не стоит использовать Deep Agents

deepagents имеет смысл когда:

  • Задача требует планирования и нескольких шагов для выполнения

  • Результаты инструментов объёмны и требуют управления на протяжении длительной сессии

  • Вы хотите делегирование субагентам без построения инфраструктуры вручную

  • Нужна постоянная память между потоками разговоров

  • Вы строите кодового агента или автономную исследовательскую систему

Оставайтесь с create_agent из LangChain или чистым LangGraph когда:

  • Агент простой: один-два вызова инструментов, короткие ответы

  • Нужен очень тонкий контроль над топологией графа

  • Вы уже глубоко в кастомном LangGraph-пайплайне и не хотите категоричных настроек по умолчанию

Библиотека честно говорит об этом в собственной документации: для простых агентов используйте простые инструменты.

Почему это важнее, чем очередной релиз фреймворка

Стоит обратить внимание на тайминг.

Агентные системы находятся в точке перелома. Базовые паттерны — вызов инструментов, циклы ReAct, простой RAG — хорошо изучены. Над чем индустрия работает сейчас — как сделать агентов надёжными на длительных задачах: задачах, требующих планирования, большого контекста, персистентности и делегирования.

Каждая команда, строящая продакшн-агентов, была вынуждена проектировать решения этих задач с нуля. Стратегии управления контекстом, паттерны субагентов, архитектуры памяти — всё это заново изобретается в слегка разных формах по всей индустрии.

deepagents — ставка LangChain на то, что эти решения достаточно типичны, чтобы их стандартизировать. Концепция оболочки агента — категоричные настройки по умолчанию, встроенная инфраструктура, подключаемые бэкенды — это попытка сдвинуть разговор от «как нам построить водопровод?» к «что мы хотим, чтобы агент делал?».

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

Как начать работу

pip install deepagents tavily-python

Установите API-ключи:

export ANTHROPIC_API_KEY="your-key"
export TAVILY_API_KEY="your-key"
export LANGSMITH_TRACING=true  # опционально, для отладки
export LANGSMITH_API_KEY="your-key"

Полная документация, включая бэкенды, субагентов, песочницы, human-in-the-loop и CLI, доступна на docs.langchain.com/oss/python/deepagents .

Если вы строите что-то серьёзное на агентах прямо сейчас, стоит потратить один вечер, чтобы понять, где deepagents вписывается в ваш стек, даже если вы не планируете использовать его немедленно.

Подписывайтесь на наш Telegram-канал. Там мы публикуем полезные подборки от инженеров и делимся инсайтами.