LangChain Deep Agents: Integrierte Funktionen für Planung, Dateien und Subagenten.

Teams, die es ernst mit Agenten meinen, gehen in der Regel denselben Weg. Sie beginnen mit LangChain-Chains, die einfache Pipelines gut handhaben können. Dann wird die Aufgabe komplexer: Es werden Tool-Aufrufe, Schleifen sowie Ausgaben von unvorhersehbarer Länge benötigt. Die Chains reichen dann nicht mehr aus, weshalb sie zu LangGraph wechseln und dort bereits State-Schemata, bedingte Kanten sowie Code zur Graph-Kompilierung schreiben, bevor sie das eigentliche Problem angegangen sind.

LangGraph ist nicht das Problem – es ist leistungsstark. Doch es handelt sich dabei um eine Laufzeitumgebung, eine primitive Ebene, und die Leute behandeln es oft wie ein Anwendungsframework. deepagents ist LangChains Antwort auf diese Unpassung.

Was es ist

„Deep Agents“ kann fast alles bedeuten, daher genauer gesagt: deepagents ist ein eigenständiges Python-Paket, das mit pip install deepagents installiert wird und auf LangChain sowie LangGraph aufbaut. In den Dokumenten von LangChain wird es als Agent-Harness bezeichnet. Es verwendet denselben Kern-Loop zur Aufrufung von Tools wie andere Frameworks, verfügt aber über eingebaute zusätzliche Funktionen, sodass man diese nicht jedes Mal neu entwickeln muss.

Der Einstiegspunkt ist create_deep_agent(). Importieren Sie dieses zunächst:

from deepagents import create_deep_agent

Dann geben Sie ein Tool und eine Anweisung ein:

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

Das ist es im Grunde. Die Bibliothek kümmert sich um das LangGraph-Graph, den Zustand, das Streaming sowie die Verwaltung des Kontextfensters – und Sie müssen sich damit überhaupt nicht beschäftigen. Noch interessanter ist das, was bereits mitgeliefert wird.

Fünf eingebaute Funktionen

Planung durch write_todos

Jeder Deep Agent erhält automatisch ein write_todos-Tool. Bei einer komplexen Aufgabe teilt er die Arbeit in Schritte auf, markiert jeden als ausstehend, in Bearbeitung oder abgeschlossen und passt den Plan an, wenn sich die Umstände ändern. Das ist kein Trick mit Prompts – die Liste befindet sich im Agentenzustand, sodass der Agent jederzeit darauf zurückgreifen, sie aktualisieren und während einer Sitzung darauf verweisen kann. Niemand muss dem Modell sagen, dass es schrittweise denken soll, denn die Struktur ist bereits Teil der Infrastruktur.

Ein virtuelles Dateisystem

Dies könnte die größte Überraschung sein. Standardmäßig verfügt der Agent über ls, read_file, write_file, edit_file, glob und grep. Warum braucht ein Agent Dateien? Für die Kontextverwaltung.

Kontextfenster sind begrenzt, und lange Suchvorgänge, Codeausführungen oder umfangreiche Tool-Ergebnisse führen dazu, dass der Kontext schnell wächst. Deep Agents speichern umfangreichen Inhalt im virtuellen Dateisystem, anstatt ihn alles im Prompt zu behalten. Wenn ein Tool-Ergebnis mehr als 20.000 Tokens umfasst, speichert die Bibliothek es im konfigurierten Backend und hinterlässt im Kontext einen Dateipfad sowie eine 10zeilige Vorschau. Wenn der Agent den vollen Inhalt benötigt, ruft er read_file oder grep auf. Das ist weder Teilung noch Kürzung, sondern eine bewusste Auslagerung mit nachfragebasiertem Abrufen.

Der Dateisystem-Backend ist austauschbar: standardmäßig wird der Zustand im Arbeitsspeicher gespeichert, alternativ kann eine lokale Festplatte, LangGraph Store für die Persistenz über verschiedene Threads oder Sandbox-Lösungen wie Modal und Daytona verwendet werden.

Subagenten

Ein integriertes task-Tool ermöglicht es dem Hauptagenten, spezialisierte Subagenten für isolierte Teilaufgaben zu erstellen. Das ist wichtiger, als es klingt. Bei einer langwierigen Forschungsarbeit füllt ein Agent, der alles selbst handhabt, seinen Kontext mit Zwischenschritten, Suchergebnissen und teilweisen Ausgaben. Mit Subagenten übergeben Sie eine Teilaufgabe an eine neue Instanz mit einem sauberen Kontext. Diese Instanz arbeitet unabhängig, beendet ihre Arbeit und sendet anschließend eine Zusammenfassung zurück, sodass der Kontext des Hauptagenten ordentlich bleibt.

Sie können eigene Subagenten mit eigenen Tools und Systemanweisungen definieren. Beginnen Sie mit dem Import:

from deepagents import create_deep_agent, Subagent

Definieren Sie anschließend einen Überprüfer und fügen Sie ihn hinzu:

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

Ein allgemein einsetzbarer Unteragent mit Dateisystemwerkzeugen ist immer verfügbar, ohne jegliche Einrichtung erforderlich zu haben.

Automatische Zusammenfassung

Bei langwierigen Aufgaben zeigt sich, wofür die Bibliothek nützlich ist. Sobald der Kontext 85 Prozent des Modellfensters ausmacht und nichts mehr auf Dateien gespeichert werden kann, löst das System eine Zusammenfassung aus. Ein LLM erstellt eine strukturierte Zusammenfassung, die den Zweck der Sitzung, die erstellten Ergebnisse sowie die nächsten Schritte umfasst, und diese Zusammenfassung ersetzt den vollständigen Verlauf im Arbeitsspeicher. Die ursprünglichen Nachrichten werden als kanonische Aufzeichnung im Dateisystem gespeichert, sodass spezifische Informationen später wiederhergestellt werden können. Im Grunde können tiefe Agenten bei komplexen Aufgaben weiterarbeiten, ohne an Kontextgrenzen zu stoßen – etwas, was man sonst manuell mit reinem LangGraph umsetzen müsste.

Gedächtnis über Gespräche hinweg

Normalerweise bleibt der Zustand innerhalb eines Threads. Konfigurieren Sie jedoch einen CompositeBackend mit einem LangGraph Store, dann kann der Agent das Gedächtnis über Sessions und Threads hinweg beibehalten. Unter dem Pfad /memories/ oder jedem von Ihnen gewählten Pfad gespeicherte Dateien überleben Neustarts und können aus jeder Konversation gelesen werden. Nutzen Sie dies, um dem Agenten Ihre Präferenzen, die Codiergewohnheiten Ihres Repositoriums oder den Stand einer mehrere Tage andauernden Forschungsarbeit in Erinnerung zu rufen. Zuerst die Importe:

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

Dann die Verkabelung:

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
)

Wie die Komponenten miteinander verbunden sind

Viele verwechseln diese Begriffe, daher lohnt es sich, klarzustellen.

• LangChain stellt die Bausteine bereit: Modelle, Tools, Prompts und Ketten. Es bildet die Grundlage.
• LangGraph ist eine Laufzeitumgebung für zuverlässige, zustandsbasierte, graphbasierte Ausführungen, die Persistenz, Streaming, Unterbrechungen sowie komplexe bedingte Abläufe handhabt. Es ist der Motor.
• Deep Agents ist eine Überbauung für beides. Es ersetzt LangGraph nicht. Es verwendet LangGraph für alles und fügt eine höherwertige API mit vorgegebenen Standardwerten hinzu, sodass Sie den Planer, die Dateisystemschicht, die Kontextkompression sowie die Infrastruktur für Unteragenten nicht selbst erstellen müssen.

Um es bildlich zu machen: LangGraph liefert Ihnen einen Motor und ein Getriebe, während Deep Agents Ihnen ein Auto überreicht.

Für einfache Agenten reicht vermutlich LangChains create_agent. Wenn die Aufgaben komplex, zeitaufwändig sind und viel Kontext benötigen, zeigt sich hier der Vorteil von deepagents durch seine Abstraktionsfähigkeit.

Eine realistische Schnellstart-Anleitung: ein Forschungsagent

Hier ist ein Forschungsagent, der im Internet sucht und einen strukturierten Bericht erstellt. Zuerst kommt die Einrichtung:

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

Dann das Tool, die Anleitung und der Agent selbst:

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)

Durch die Ausführung wird eine Abfolge in Gang gesetzt. Der Agent ruft write_todos auf, um die Forschung zu planen. Er führt Suchanfragen durch und leitet große Ergebnismengen automatisch an das virtuelle Dateisystem weiter. Wenn die Arbeit umfangreich ist, startet er einen Unteragenten für einen bestimmten Abschnitt. Bei Bedarf liest er die Dateien erneut ein und fasst alles in einen Endbericht zusammen. Die gesamte Zeit über verwaltet das Framework den Kontext, sodass das Modell niemals seine Speichergrenze überschreitet. Sie haben keine dieser Infrastrukturen selbst entwickelt, da sie bereits mit dem Framework mitgeliefert wurden.

Der Kommandozeilenagent

Das Paket enthält außerdem einen Terminalagenten, der auf derselben SDK-Basis gebaut ist:

pip install deepagents
deepagents  # launches the interactive CLI agent

Es handelt sich um einen Programmieragenten im Stil von Claude Code oder Aider, der jedoch auf dem Deep Agents SDK läuft. Er bietet einen interaktiven Modus, einen nicht-interaktiven Pipe-Modus für Skripting (-n-Flag), benutzerdefinierte Fähigkeiten sowie persistente Speicherung. Lehren Sie ihm Ihre Projektkonventionen, und er wird sich diese von einer Sitzung zur nächsten merken. Somit liefert das SDK, das einen produktiven Forschungsagenten antreibt, sofort auch ein nutzbares Entwicklerwerkzeug.

Wann ist es geeignet?

deepagents eignet sich für Sie, wenn:

• Die Aufgabe Planung und viele Schritte erfordert.
• Die Ergebnisse der Tools umfangreich sind und über eine lange Sitzung hinweg verwaltet werden müssen.
• Sie Subagenten einsetzen möchten, ohne die entsprechende Infrastruktur selbst aufbauen zu müssen.
• Ihnen eine Speicherung benötigt wird, die über verschiedene Konversationen hinweg bestehen bleibt.
• Sie einen Programmieragenten oder ein autonomes Forschungssystem entwickeln.

Bleiben Sie bei create_agent oder dem reinen LangGraph, wenn:

• Der Agent einfach ist, mit ein oder zwei Toolaufrufen und kurzen Antworten.
• Sie eine präzise Kontrolle über die Graph-Topologie benötigen.
• Sie bereits tief in einem benutzerdefinierten LangGraph-Ablauf sind und keine vorgefertigten Standards wollen.

Die Dokumentation selbst besagt dies: Einfache Agenten erfordern einfachere Tools.

Warum das wichtig ist

Die zeitliche Entwicklung sagt etwas aus. Grundlegende Agentenmuster, Toolaufrufe, ReAct-Schleifen sowie einfaches RAG sind inzwischen gut verstanden. Was das Feld noch herausfinden muss, ist die Zuverlässigkeit bei langfristigen Aufgaben – Aufgaben, die Planung, großen Kontext, Persistenz und Delegation erfordern. Jedes Team, das produktive Agenten einsetzt, musste diese gleichen Probleme von Grund auf lösen, und Strategien zur Handhabung des Kontexts, Muster für Unteragenten sowie Speicherdesigns werden ständig in leicht abgewandelter Form neu entwickelt.

deepagents ist LangChains Wette darauf, dass solche Lösungen häufig genug vorkommen, um standardisiert zu werden. Ein Framework mit vorgegebenen Standardwerten, integrierter Infrastruktur sowie anschließbaren Backend-Lösungen versucht, die Frage von „Wie bauen wir die Grundstruktur?“ auf „Was sollte der Agent eigentlich tun?“ zu verlagern. Ob es erfolgreich ist, hängt davon ab, ob die Standardwerte in der Produktion Bestand haben. Als Richtung macht es jedoch Sinn.

Erste Schritte

Installieren Sie das Paket sowie den Suchclient:

pip install deepagents tavily-python

Stellen Sie anschließend Ihre Schlüssel ein:

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"

Die Übersicht zu Deep Agents in den LangChain-Dokumentationen behandelt Backend-Systeme, Subagenten, Sandboxes, den Human-in-the-Loop-Ansatz sowie die CLI. Wenn Sie etwas Ernsthaftes mit Agenten entwickeln, nehmen Sie sich einen Nachmittag Zeit, um herauszufinden, wie diese Elemente in Ihr technisches Umfeld passen – auch wenn Sie sie nicht sofort übernehmen.