logo
Entwicklung
Suchen
Subagenten-System

Subagenten-System

Überblick

Der Subagent ist der Mechanismus des Arbeitsbereichs zur Aufgabenzerlegung und Delegation. Der Haupt-Agent kann komplexe parallele Aufgaben in Teilaufgaben aufteilen und spezialisierte Subagenten erstellen, die diese eigenständig ausführen. Nach Abschluss geben die Subagenten ihre Ergebnisse an den Haupt-Agenten zurück, der die weitere Verarbeitung übernimmt.

Das System unterstützt drei Arten von Subagenten mit einer maximalen Verschachtelungstiefe von 3 Ebenen.

Drei Arten von Subagenten

Typ Werkzeugname Erstellungsweise Anwendungsfall Ausführungsort
Automatische Erstellung create_local_sub_agent Vom Agenten während der Schlussfolgerung eigenständig erstellt Temporäre Aufgabenzerlegung Lokaler Knoten
Vorregistrierte Verteilung dispatch_sub_agent Vom Benutzer vorab konfiguriert Feste Fachrollen zur wiederholten Nutzung Lokaler Knoten
Knotenübergreifende Verteilung dispatch_multi_node_agent Vom Agenten ausgewählter Remote-Knoten Bedarf an entfernten Ressourcen oder Fähigkeiten Remote-Knoten

Automatische Erstellung von Subagenten (create_local_sub_agent)

Wenn der Agent während des Schlussfolgerungsprozesses feststellt, dass die aktuelle Aufgabe zerlegt werden muss, ruft er eigenständig das Werkzeug create_local_sub_agent auf, um einen temporären Subagenten zu erstellen. Benutzer können den Agenten auch über Dialog-Prompts auffordern, einen Subagenten zu erstellen, zum Beispiel:

„Bitte erstelle einen Subagenten, der für die Suche nach relevanten Materialien zuständig ist, und erstelle dann einen weiteren Subagenten, der die Dokumentation schreibt."

Erstellungsparameter:

Parameter Beschreibung Pflichtfeld
task Aufgabenbeschreibung des Subagenten Ja
systemPrompt Identitäts-/Rollendefinition des Subagenten Ja
cwd Arbeitsverzeichnis (erbt standardmäßig von der übergeordneten Ebene) Nein
maxSpawnDepth Verschachtelungstiefe (1-3), Standardwert 1 Nein

Ausführungsablauf:

  1. Der Haupt-Agent beschließt, einen Subagenten zu erstellen, und legt die Aufgabe fest
  2. Das System startet eine eigenständige Agent Loop (standardmäßig maximal 50 Runden)
  3. Der Subagent verfügt über eine eigene Werkzeugschleife, der Ausführungsprozess ist im übergeordneten Dialogfenster sichtbar
  4. Nach Abschluss gibt der Subagent das Endergebnis an den Haupt-Agenten zurück
  5. Der Haupt-Agent setzt die weitere Arbeit auf Basis des Ergebnisses fort

Vorregistrierte Verteilung von Subagenten (dispatch_sub_agent)

Benutzer können in den APP-Einstellungen Subagenten mit spezifischer Konfiguration vorab registrieren, die der Agent bei Bedarf über das Werkzeug dispatch_sub_agent aufruft.

Die Beschreibung vorregistrierter Subagenten wird automatisch in den Systemprompt des Haupt-Agenten eingefügt. Wenn das LLM eine passende Aufgabe erkennt, wählt es automatisch den geeigneten Subagenten aus.

Konfigurationsoptionen:

Konfiguration Beschreibung
name Name des Subagenten
description Fähigkeitsbeschreibung (wird in den Systemprompt des übergeordneten Agenten eingefügt)
systemPrompt Identitäts-/Rollendefinition
tools Werkzeug-Whitelist (bei Auslassung werden alle geerbt)
disallowedTools Werkzeug-Blacklist
skills Liste verfügbarer Skill-IDs
mcpServers Liste verfügbarer MCP-Servernamen
model Überschreibt das Modell der übergeordneten Ebene
maxTurns Überschreibt die standardmäßige maximale Rundenzahl
canSpawn Ob untergeordnete Subagenten erstellt werden können
maxSpawnDepth Maximale Verschachtelungstiefe

Details zur Verwaltungsoberfläche finden Sie unter Registrierung und Verwaltung von Subagenten.


Knotenübergreifende Verteilung (dispatch_multi_node_agent)

Wenn eine Aufgabe Ressourcen oder Fähigkeiten eines entfernten Geräts erfordert, kann der Agent die Aufgabe über das Werkzeug dispatch_multi_node_agent an andere Knoten verteilen.

Arbeitsablauf:

  1. Der Haupt-Agent sieht die Liste der Online-Knoten ein (in den Systemprompt eingefügt)
  2. Auswahl des Zielknotens anhand der deklarierten Knotenfähigkeiten
  3. Senden von node.invoke.request über Gateway WebSocket
  4. Der Remote-Knoten startet eine eigenständige Agent Loop zur Ausführung der Aufgabe
  5. Nach Abschluss wird das Ergebnis über node.invoke.result zurückgegeben

Beispielszenario:

  • Ein Dialog wird über das Web-Frontend auf Computer A gestartet
  • Die Aufgabe erfordert den Zugriff auf lokale Dateien auf Computer B
  • Der Agent verteilt die Teilaufgabe der Dateioperation über das Gateway an den APP-Knoten von Computer B
  • Der Knoten B führt die Aufgabe aus und gibt das Ergebnis zurück, der Dialog wird auf Computer A weiter angezeigt

Steuerung der Verschachtelungstiefe

Subagenten unterstützen verschachtelte Erstellung mit einer maximalen Tiefe von 3 Ebenen:

Tiefe 0: Haupt-Agent (Benutzerdialog) └── Tiefe 1: Subagent A └── Tiefe 2: Sub-Subagent A-1 └── Tiefe 3: Tiefster Agent (keine weitere Delegation möglich)
                      
                      Tiefe 0: Haupt-Agent (Benutzerdialog)
  └── Tiefe 1: Subagent A
        └── Tiefe 2: Sub-Subagent A-1
              └── Tiefe 3: Tiefster Agent (keine weitere Delegation möglich)

                    
Dieser Codeblock im schwebenden Fenster
Parameter Wert Beschreibung
DEFAULT_MAX_SPAWN_DEPTH 1 Standard: Subagent kann keine untergeordnete Ebene erstellen
MAX_ALLOWED_SPAWN_DEPTH 3 Harte Obergrenze
SUBAGENT_DEFAULT_MAX_TURNS 50 Standardmäßige maximale Rundenzahl des Subagenten (höher als die 25 des Haupt-Agenten)

Je höher die Tiefe, desto größer die Autonomie, aber auch der Token-Verbrauch und die Ausführungszeit steigen entsprechend.

Werkzeug-Vererbungsmechanismus

Modus Beschreibung
Standardvererbung Der Subagent erbt alle verfügbaren Werkzeuge des übergeordneten Agenten
Whitelist Der Parameter tools gibt die Liste der erlaubten Werkzeuge an
Blacklist Der Parameter disallowedTools schließt bestimmte Werkzeuge aus
Skill-Vererbung Skills und MCP-Server der übergeordneten Ebene können geerbt oder überschrieben werden
Modellüberschreibung Der Subagent kann ein anderes LLM-Modell als die übergeordnete Ebene verwenden

UI-Darstellung

Subagenten werden im Work-Dialogfenster mit einer besonderen Kennzeichnung dargestellt:

Darstellung des Werkzeugaufrufs durch Subagenten-CN

Anzeigeelement Beschreibung
SubagentToolRow Werkzeugaufrufzeile speziell für Subagenten, mit besonderer Farbkennzeichnung (Smaragdgrün, emerald)
Aktivitätsdurchleitung Der Werkzeugaufrufprozess des Subagenten wird in Echtzeit im übergeordneten Dialogfenster angezeigt
Ergebnisanzeige Nach Abschluss des Subagenten wird das Endergebnis als Werkzeugausgabe dargestellt

Benutzer können deutlich erkennen, welche Operationen vom Haupt-Agenten und welche vom Subagenten ausgeführt werden.



So erstellen Sie einen Subagenten über den Dialog

Sie können den Agenten im Dialog in natürlicher Sprache auffordern, einen Subagenten zu erstellen. Hier einige Beispiel-Prompts:

Prompt Wirkung
„Erstelle einen Subagenten, der relevante Materialien sucht und aufbereitet" Der Agent erstellt einen auf die Suche fokussierten Subagenten
„Teile diese Aufgabe auf zwei Subagenten auf: einer für den Code, einer für die Dokumentation" Der Agent erstellt zwei Subagenten mit jeweils eigener Spezialisierung
„Erstelle mir einen Subagenten mit Tiefe 2 zur Bearbeitung dieser komplexen Aufgabe" Der Agent erstellt einen Subagenten, der weiter delegieren kann
„Nutze einen Remote-Knoten zur Ausführung dieser Dateiverarbeitungsaufgabe" Der Agent verwendet dispatch_multi_node_agent

Interpretation der Oberfläche während der Subagenten-Ausführung

Ausführungsprozess des Subagenten-CN

UI-Element Bedeutung
Smaragdgrün gekennzeichnete Werkzeugzeile Dies ist ein Werkzeugaufruf, der gerade vom Subagenten ausgeführt wird
Werkzeugaufruf „create_local_sub_agent" Der Haupt-Agent erstellt gerade einen Subagenten
Werkzeugaufruf innerhalb des Subagenten Vom Subagenten eigenständig ausgewählter Werkzeugaufruf, in Echtzeit angezeigt
Endergebnis Zusammenfassende Ausgabe nach Abschluss des Subagenten

Kostenauswirkungen

Der Token-Verbrauch von Subagenten wird unabhängig berechnet:

Szenario Geschätzter Token-Verbrauch
Nur Haupt-Agent (ohne Subagenten) 1x
Haupt-Agent + 1 Subagent 1,5x ~ 2,5x
Haupt-Agent + 2 Subagenten 2x ~ 4x
3-stufige Verschachtelung (Haupt + Sub + Enkel + Urenkel) 3x ~ 6x

Empfehlung: Subagenten eignen sich für komplexe Aufgaben, die tatsächlich zerlegt werden müssen. Einfache Aufgaben sollte direkt der Haupt-Agent bearbeiten, ohne dass ein Subagent erstellt werden muss.

Wann Subagenten eingesetzt werden sollten / nicht

Für Subagenten geeignet Kein Subagent erforderlich
Aufgabe teilt sich natürlich in unabhängige Teile auf (z. B.: Materialsuche + Dokumentation schreiben) Einzelne lineare Aufgabe (z. B.: eine Datei lesen und zusammenfassen)
Verschiedene fachliche Perspektiven erforderlich (z. B.: Code-Review + Sicherheitsaudit) Einfache Frage-Antwort
Ressourcen entfernter Knoten erforderlich (z. B.: Dateien auf einem Remote-Server) Lokale Dateioperationen
Großer Aufgabenumfang, der durch Parallelisierung beschleunigt werden kann Einfache und schnelle Aufgabe

Es wird nicht empfohlen, SubAgents unterschiedliche Rollen zur arbeitsteiligen Zusammenarbeit zuzuweisen; im KI-Zeitalter senkt Zusammenarbeit sogar Effizienz und Qualität. Besser geeignet sind Szenarien der parallelen Aufgabenausführung, um Zeit zu sparen und die Effizienz zu steigern.

Verwandte Dokumente