Wie dynamische Subagents KI-Skalierung und Kontextgrenzen lösen

Wenn Agenten immer ambitioniertere Aufgaben übernehmen, haben sie Schwierigkeiten mit:

Zuverlässiger Erledigung von Arbeit in großem Umfang
Verwaltung des eigenen Kontexts

Wir haben experimentiert, wie man diese Herausforderungen in Form von sogenannten dynamischen Subagenten bewältigen kann: Anstatt Subagenten-Aufgaben durch generische Tool-Aufrufe zu erteilen, schreibt der Agent ein kurzes Skript, das die Ausführung der Subagenten steuert. So können sich Modelle auf Codemuster verlassen, die sie gut beherrschen (wie Schleifen, Verzweigungen oder Nebenläufigkeit), um eine auf die Aufgabe zugeschnittene Orchestrierungslogik zu schreiben.

Warum dynamische Subagenten?

Deep Agents unterstützt bereits Subagenten. Sie isolieren den Kontext, lassen den Haupt-Agenten diskrete Arbeitseinheiten delegieren und halten Zwischenergebnisse aus dem Hauptkontextfenster fern. Warum brauchen wir dann dynamische Subagenten?

Bei normalen Subagenten werden diese einzeln aufgerufen, indem das Hauptmodell sie direkt ansteuert. Das funktioniert in kleinem Maßstab. Es bricht zusammen, wenn man hunderte von Subagenten spawnen muss oder wenn die Orchestrierungslogik bedingt oder mehrphasig ist.

Dynamische Subagenten lösen dies durch programmatische Orchestrierung. Anstatt Tool-Aufrufe Schritt für Schritt zu machen, schreibt der Agent ein kurzes Skript, das Subagenten orchestriert und aufruft, und führt es in einem leichtgewichtigen Interpreter aus.

Das kanonische Beispiel: ein Subagent pro Seite eines 300-seitigen Dokuments. Anstatt das Subagenten-Tool 300 Mal aufzurufen, schreibt der Agent eine Schleife:

javascript

1const results = await Promise.all(pages.map(page =>
2  task({ description: `Fasse Seite ${page.number} zusammen`, subagentType: "summarizer" })
3));

Dies ermöglicht zwei Dinge, die eine auf Tool-Aufrufen basierende Orchestrierung nicht zuverlässig liefern kann:

Deterministische Abdeckung in großem Umfang. Ohne Struktur treffen Agenten subjektive Entscheidungen über den Umfang, screenen 75 von 500 Elementen und erklären die Aufgabe für erledigt. Eine Verteilschleife tut das nicht. Abdeckung wird zu einer strukturellen Garantie, nicht zu einem Prompt-Engineering-Problem.

Zuverlässige komplexe Orchestrierung. Das Schreiben der Orchestrierung als Code ist zuverlässiger, als das Modell sie als Folge von Tool-Aufrufen reproduzieren zu lassen, insbesondere bei Fan-Out + Synthese, mehrphasigen Pipelines oder bedingten Verzweigungen.

Dies ist die gleiche Idee wie hinter Workflows in Claude Code und Recursive Language Models (RLMs): Ein Modell schreibt Code, und dieser Code setzt weitere Agenten ein.

Schnellstart

Dynamische Subagenten benötigen zwei Dinge: Subagenten, an die Arbeit verteilt wird, und einen Code-Interpreter: eine sichere, leichtgewichtige Laufzeitumgebung, in der das Modell Orchestrierungscode schreibt und ausführt. Deep Agents enthält einen optionalen Code-Interpreter basierend auf QuickJS. Um ihn zu verwenden, installieren Sie das QuickJS-Middleware-Paket und übergeben Sie dann CodeInterpreterMiddleware über das middleware-Argument an create_deep_agent.

bash

1pip install -U "deepagents[quickjs]"

python

1from deepagents import create_deep_agent
2from langchain_quickjs import CodeInterpreterMiddleware
3
4agent = create_deep_agent(
5    model="openai:gpt-5.5",
6    middleware=[CodeInterpreterMiddleware()],
7)

Deep Agents wird mit einem allgemeinen Subagenten ausgeliefert, sodass bereits ein allgemeines Subagentenprofil vorhanden ist, das in Workflows verwendet werden kann. Konfigurieren Sie für spezialisierte Workflows benutzerdefinierte Subagenten mit eigenen Namen, Beschreibungen und System-Prompts: Die Namen und Beschreibungen geben dem Agenten vor, welche Rolle er verwenden soll.

Um dynamische Subagenten auszulösen, geben Sie Ihrem Agenten den Prompt mit dem Wort "workflow", wie folgt:

python

1result = await agent.ainvoke({
2    "messages": [{"role": "user", "content": "Führe einen Workflow aus, der jede Datei in src/routes/ überprüft und die Top-Risiken zusammenfasst."}]
3})

Verwendung mit einem Coding-Agent

Der schnellste Weg, dynamische Subagenten auszuprobieren, ist dcode, unser terminalbasierter Coding-Agent, der auf einem Deep Agent basiert. Er wird mit aktiviertem Code-Interpreter ausgeliefert, sodass nichts zusätzlich konfiguriert werden muss – dynamische Subagenten funktionieren sofort.

Installation

bash

1curl -LsSf https://langch.in/dcode | bash

Ausführen

bash

1dcode

Um dynamische Subagenten auszulösen, fragen Sie einfach nach einem "Workflow". Anstatt die Arbeit selbst zu erledigen oder zu versuchen, Subagenten-Fan-Outs mit dem nativen Task-Tool zu verwalten, schreibt der Agent ein Orchestrierungsskript, das die integrierte task()-Globale aufruft und sie im Code-Interpreter ausführt. Zum Beispiel: „Führe einen Workflow aus, der jede Datei in src/ auf SQL-Injection überprüft."

Wenn Subagenten spawnen, zeigt dcode sie live im dynamischen Subagenten-Panel an, gruppiert in Phasen nach Dispatch.

Sie können dies am schnellsten mit dcode ausprobieren, aber Sie können es auch in Ihrem bevorzugten Tool über ACP (z. B. Zed) verwenden.

So funktioniert es

Dem Agenten wird ein eval-Tool zur Verfügung gestellt. Er schreibt JavaScript, das sicher innerhalb des Interpreters ausgeführt wird. Wenn Subagenten konfiguriert sind, stellt der Interpreter eine integrierte task()-Globale bereit, die diese aus dem Code heraus aufruft. Basierend auf der anstehenden Aufgabe schreibt das Modell unterschiedlichen Code – eine Schleife, eine Verzweigung, ein Promise.all – und der Interpreter führt ihn deterministisch aus.

task() erwartet eine Beschreibung, einen subagentType und optional ein responseSchema – wenn angegeben, ist das Ergebnis bereits ein typisiertes Objekt, bereit zum Filtern oder zur Übergabe an den nächsten Schritt.

javascript

1const result = await task({
2  description: "Überprüfe src/auth/login.ts auf Sicherheitsprobleme.",
3  subagentType: "reviewer",
4  responseSchema: {
5    type: "object",
6    properties: {
7      severity: { type: "string", enum: ["hoch", "mittel", "niedrig"] },
8      issues: { type: "array", items: { type: "string" } },
9    },
10  },
11});
12
13const critical = result.severity === "hoch" ? result.issues : [];
14critical; // Das Modell sieht die letzte Zeile

Weitere Informationen finden Sie unter Programmatische Subagenten und Interpreter in der Dokumentation.

Gängige Orchestrierungsmuster

Anthropics dynamische Workflows haben eine Reihe von Orchestrierungsmustern für die parallele Arbeit von Agenten populär gemacht. Es handelt sich nicht um Funktionen, die man einschaltet. Es sind Formen, die sich natürlich aus der Arbeit ergeben, und der Agent nimmt eine andere an, wenn sich die Aufgabe ändert. Die folgende Tabelle ordnet jede Form der Art von Arbeit zu, für die sie geeignet ist.

Im Folgenden gehen wir darauf ein, wie jedes einzelne Muster in Deep Agents funktioniert, mit Live-Traces. Wir haben auch ein Video zusammengestellt, das diese sechs Muster erklärt und das Sie hier ansehen können.

Klassifizieren und handeln

Elemente werden zuerst klassifiziert, dann wird jedes Element basierend auf seiner Klassifizierung von einem spezialisierten Subagenten bearbeitet. Dies ermöglicht die Verarbeitung gemischter Eingaben, bei denen verschiedene Elemente unterschiedliches Fachwissen erfordern.

Anwendungsfälle: Sortieren von Support-Tickets, Fehlerprotokollen, Benutzerfeedback oder beliebigen Stapeln von Elementen, die je nach Typ unterschiedlich behandelt werden müssen.

Beispiel: Sortieren eines Rückstands von Support-Tickets. Der Agent liest die Tickets und klassifiziert jedes als Fehler, Feature-Anfrage oder Frage. Fehler an einen Fehlerermittler, Feature-Anfragen an einen Feature-Analysten und Fragen an einen Support-Bearbeiter. Das Ergebnis ist eine nach Kategorie gruppierte Zusammenfassung.