LangChain Deep Agents: wbudowane funkcje planowania, zarządzania plikami i podagentami.

Zespoły, które poważnie podchodzą do agentów, zazwyczaj podążają tą samą ścieżką. Zaczynają od łańcuchów LangChain, które dobrze radzą sobie z prostymi procesami. Następnie zadanie staje się bardziej złożone: wymagają one wywołań narzędzi, pętli oraz wyników o nieprzewidywalnej długości. Łańcuchy już nie wystarczają, więc przechodzą na LangGraph, gdzie muszą tworzyć schematy stanów, warunkowe krawędzie oraz kod do kompilacji grafu, zanim w ogóle zajmą się rzeczywistym problemem.

LangGraph nie jest problemem – jest potężny. Jednak jest to środowisko wykonawcze, prymitywa niskiego poziomu, a ludzie często traktują go jak framework aplikacyjny. deepagents to odpowiedź LangChain na tę niezgodność.

Czym jest

„Głębokie agenty” mogą oznaczać niemal cokolwiek, więc dla dokładności: deepagents to samodzielny pakiet w Pythonie, który instaluje się za pomocą pip install deepagents i działa na bazie LangChain oraz LangGraph. Dokumentacja LangChain określa go jako narzędzie do zarządzania agentami. Wykorzystuje tę samą pętlę wywoływania narzędzi co inne frameworki, ale posiada wbudowane dodatkowe funkcje, dzięki czemu nie trzeba ich ponownie tworzyć za każdym razem.

Punkt wejścia to create_deep_agent(). Najpierw należy go zaimportować:

from deepagents import create_deep_agent

Następnie podaj narzędzie i polecenie:

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

To właśnie cała sprawa. Biblioteka zajmuje się zarządzaniem grafem LangGraph, stanem, strumieniowaniem oraz oknem kontekstowym, a ty w ogóle nie musisz się tym zajmować. Bardziej interesująca jest część, która jest włączona przez domyślność.

Pięć wbudowanych funkcji

Planowanie za pomocą write_todos

Każdy zaawansowany agent automatycznie otrzymuje narzędzie write_todos. W przypadku skomplikowanego zadania agent dzieli je na kroki, oznacza każdy z nich jako w toku, w przygotowaniu lub zakończony, a także dostosowuje plan w miarę zmian. To nie jest żaden trik związany z promptem – lista znajduje się w stanie agenta, więc może do niej wracać, ją aktualizować i korzystać z niej przez całą sesję. Nikt nie musi mówić modelowi, aby myślał krok po kroku, ponieważ taka struktura jest częścią oprogramowania.

Wirtualny system plików

To może być największe zaskoczenie. Domyślnie agent posiada funkcje ls, read_file, write_file, edit_file, glob oraz grep. Po co agentowi pliki? Do zarządzania kontekstem.

Okna kontekstowe są skończone, a długie procesy badawcze, wykonywanie kodu lub duże wyniki narzędzi sprawiają, że historia szybko się powiększa. Agenci typu „deep” przechowują objętościowy kontent w wirtualnym systemie plików zamiast trzymać go wszystko w wiadomości wejściowej. Gdy wynik narzędzia przekracza 20 000 tokenów, biblioteka zapisuje go w skonfigurowanym backendzie i pozostawia w kontekście ścieżkę do pliku wraz z 10-wierszowym wycinkiem. Gdy agent potrzebuje pełnego tekstu, wywołuje funkcję read_file lub grep. Nie chodzi tu ani o dzielenie na fragmenty, ani o skracanie treści – to celowe przenoszenie obciążenia z możliwością pobierania danych na żądanie.

Tło systemu plików jest dostosowywalne: domyślnie stan w pamięci, dysk lokalny, LangGraph Store do przechowywania danych między wątkami lub środowiska typu sandbox, takie jak Modal i Daytona.

Podagenty

Wbudowany narzędzie task umożliwia głównemu agentowi tworzenie specjalistycznych podagentów do wykonywania izolowanych podzadań. Ma to większe znaczenie, niż się wydaje. W długotrwałych zadaniach badawczych agent zajmujący się wszystkim wypełnia swój kontekst krokami pośrednimi, wynikami wyszukiwania i częściowymi wynikami. Dzięki podagentom główny agent przekazuje podzadanie nowej instancji z czystym kontekstem. Ta instancja pracuje samodzielnie, kończy zadanie i zwraca jeden podsumowanie, dzięki czemu kontekst głównego agenta pozostaje uporządkowany.

Można zdefiniować własne podagenty z ich własnymi narzędziami i wskazówkami systemowymi. Zacznij od imporту:

from deepagents import create_deep_agent, Subagent

Następnie zdefiniuj recenzenta i dołącz go:

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.",
)

Uniwersalny podagent z narzędziami do systemu plików jest zawsze dostępny bez żadnej konfiguracji.

Automatyczne streszczanie

W przypadku długotrwałych zadań to właśnie tutaj biblioteka sprawdza się najlepiej. Gdy kontekst osiąga 85% możliwości modelu i nie ma już nic do zapisania w plikach, system uruchamia proces streszczania. Model językowy tworzy ustrukturyzowane streszczenie obejmujące cel sesji, utworzone pliki oraz kolejne kroki, a to streszczenie zastępuje pełną historię w pamięci roboczej. Oryginalne wiadomości są zapisywane w systemie plików jako oficjalny zapis, dzięki czemu można je później odzyskać. W praktyce zaawansowane agenty mogą kontynuować wykonywanie złożonych zadań bez przekraczania limitów kontekstu, co w inny sposób wymagałoby ręcznej konfiguracji w surowym LangGraph.

Pamięć między rozmowami

Zazwyczaj stan pozostaje w obrębie jednego wątku. Jeśli jednak skonfigurujesz CompositeBackend z LangGraph Store, agent może przechowywać pamięć między sesjami i wątkami. Pliki przechowywane w ścieżce /memories/ lub w dowolnej innej wybranej ścieżce przetrwają restarty i mogą być odczytywane z dowolnej rozmowy. Użyj tego, aby agent mógł przypomnieć sobie twoje preferencje, nawyki programistyczne z repozytorium lub to, gdzie przerwano badania trwające kilka dni. Najpierw importy:

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

Następnie okablowanie:

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
)

Jak elementy się łączą

Ludzie często je mylą, więc warto być precyzyjnym.

• LangChain dostarcza elementy budulcowe: modele, narzędzia, prompty i łańcuchy. To fundament.
• LangGraph to środowisko wykonawcze do trwałej, stanowej eksploatacji opartej na grafach, obsługujące przechowywanie danych, transmisję danych, przerwy oraz złożone struktury warunkowe. To silnik.
• Deep Agents to narzędzie oparte na obu tych rozwiązaniach. Nie zastępuje LangGraph – wykorzystuje go we wszystkim i dodaje API wyższego poziomu z ustalonymi domyślnymi ustawieniami, dzięki czemu nie musisz samodzielnie budować mechanizmów planowania, warstwy plików, kompresji kontekstu ani infrastruktury podagentów.

Można to sobie wyobrazić tak: LangGraph dostarcza silnik i skrzynię biegów, a Deep Agents daje samochód.

Dla prostych agentów funkcja create_agent z LangChain prawdopodobnie wystarczy. Gdy zadania są złożone, długotrwałe i wymagają dużo kontekstu, wtedy właśnie deepagents rekompensuje koszt swojej abstrakcji.

Rzeczywisty szybki start: agent do badań

Oto agent do badań, który przeszukuje internet i tworzy ustrukturyzowany raport. Najpierw konieczna jest konfiguracja:

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

Następnie narzędzie, instrukcje oraz sam 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)

Uruchomienie go inicjuje określoną sekwencję działań. Agent wywołuje funkcję write_todos, aby zaplanować badania. Przeprowadza wyszukiwania i automatycznie przenosi duże ilości wyników do wirtualnego systemu plików. Jeśli praca jest obfita, uruchamia podagenta do zajęcia się poszczególnymi sekcjami. Gdy to konieczne, odczytuje pliki i łączy wszystko w ostateczny raport. Przez cały czas narzędzie zarządza kontekstem, dzięki czemu model nigdy nie przekracza ustalonego limitu pamięci. Nie napisałeś żadnej z tych elementów infrastruktury – zostały one dostarczone wraz z tym narzędziem.

Agent w linii poleceń

Pakiet zawiera również agenta terminalowego stworzonego na bazie tego samego SDK:

pip install deepagents
deepagents  # launches the interactive CLI agent

To agent do programowania w stylu Claude Code lub Aider, ale działający na bazie Deep Agents SDK. Oferuje tryb interaktywny, tryb niestandardowy typu „pipe” do pisania skryptów (flaga -n), dostosowane umiejętności oraz trwałą pamięć. Naucz go konwencji swojego projektu, a on zapamięta je między sesjami. Dzięki temu SDK, które napędza agenta do badań produkcyjnych, dostarcza od razu przydatnego narzędzia dla programistów.

Kiedy go używać

deepagents będzie odpowiedni, gdy:

• Zadanie wymaga planowania i wielu kroków.
• Wyniki narzędzi są obszerne i muszą być zarządzane przez dłuższy czas.
• Chcesz delegować zadania podagentom bez konieczności budowania odpowiedniej infrastruktury.
• Potrzebujesz pamięci, która przetrwa różne wątki rozmowy.
• Budujesz agenta do programowania lub autonomiczny system badawczy.

Zostań przy create_agent lub zwykłym LangGraph, gdy:

• Agent jest prosty, z jednym lub dwoma wywołaniami narzędzi i krótkimi odpowiedziami.
• Potrzebujesz ścisłej kontroli nad topologią grafu.
• Jesteś już w zaawansowanym procesie pracy z dostosowanym LangGraph i nie chcesz używać domyślnych ustawień narzuconych przez twórców.

Sam dokument to potwierdza: proste agenty wymagają prostszych narzędzi.

Dlaczego to ma znaczenie

Czas rozwoju pokazuje pewne tendencje. Podstawowe wzorce agentów, wywoływanie narzędzi, pętle ReAct oraz proste rozwiązania typu RAG są już dobrze znane. To, nad czym naukowcy nadal pracują, to niezawodność w zadaniami długoterminowych, wymagających planowania, dużego kontekstu, trwałości i delegowania zadań. Każdy zespół tworzący produkcyjne agenty musiał rozwiązywać te same problemy od zera, a strategie obsługi kontekstu, wzorce podagentów oraz projekty pamięci są ciągle reinnowowane w nieco innych formach.

deepagents to próba LangChain, by te rozwiązania były na tyle powszechne, by można je było ustandaryzować. Narzędzie z ustalonymi domyślnymi ustawieniami, wbudowaną infrastrukturą oraz możliwością podłączania różnych backendów ma na celu przeniesienie pytania z „jak zbudować podstawową strukturę?” na „co właściwie powinien robić agent?”. Sukces tego podejścia zależy od tego, czy domyślne ustawienia przetrwają w środowisku produkcyjnym. Jako kierunek rozwoju ma to jednak sens.

Pierwsze kroki

Zainstaluj pakiet oraz klient do wyszukiwania:

pip install deepagents tavily-python

Następnie ustaw swoje klucze:

export ANTHROPIC_API_KEY="your-key"
export TAVILY_API_KEY="your-key"
export LANGSMITH_TRACING=true  # optional, for debugging
export LANGSMITH_API_KEY="your-key"

Przegląd Deep Agents w dokumentacji LangChain omawia backendy, subagenty, środowiska testowe, mechanizm udziału człowieka w procesie oraz interfejs wiersza poleceń. Jeśli budujesz coś poważnego z użyciem agentów, poświęć popołudnie na zrozumienie, jak pasuje to do twojej architektury, nawet jeśli nie zdecydujesz się na jego natychmiastowe wdrożenie.