Tutorial 22: Delegation an Subagenten | Easy Understand Hermes Agent

Dies ist Teil der offiziellen Hermes-Agent-Tutorialserie. Alle Tutorials ansehen

Stell dir vor, du bist der Teamleiter in einem Projekt. Du könntest zwar alles selbst machen, aber das wäre langsam. Stattdessen verteilst du bestimmte Aufgaben an deine Teammitglieder, gibst ihnen die nötigen Details und wartest auf ihre Rückmeldung. Genau das macht die Subagent-Delegation für Hermes Agent – sie ermöglicht es deinem Hauptagenten, temporäre „Arbeiter“ anzuheuern, um Aufgaben im Hintergrund zu erledigen.

Schritt 1: Verstehe die Grundidee

Wenn du delegate_task aufrufst, erstellt Hermes einen oder mehrere untergeordnete Agenten (Subagenten). Jeder davon:

Bekommt eine komplett neue Konversation – er weiß nichts über deinen Chatverlauf.
Hat Zugriff auf dieselben Tools wie der übergeordnete Agent.
Läuft in seiner eigenen isolierten Terminal-Sitzung.
Gibt nur eine endgültige Zusammenfassung an den übergeordneten Agenten zurück.

Stell es dir so vor, als würdest du einen Kollegen losschicken, um ein Thema zu recherchieren. Er sitzt nicht deiner gesamten Besprechung bei – du gibst ihm nur einen Zettel mit Aufgabe und Kontext, und er kommt mit einem Bericht zurück.

Schritt 2: Eine einzelne Aufgabe delegieren

Der einfachste Anwendungsfall: eine Aufgabe, ein Subagent.

delegate_task(
    goal="Debug why tests fail",
    context="Error: assertion in test_foo.py line 42"
)

Das goal sagt dem Subagenten, was zu tun ist. Der context liefert ihm alles, was er dafür braucht.

Schritt 3: Mehrere Aufgaben parallel delegieren

Mehrere Dinge gleichzeitig erledigen? Übergib einfach eine Liste von Aufgaben. Standardmäßig führt Hermes bis zu 3 Subagenten gleichzeitig aus (das kannst du ändern – es gibt kein festes Limit).

delegate_task(tasks=[
    {"goal": "Research topic A", "context": "Focus on recent primary sources"},
    {"goal": "Research topic B", "context": "Compare the leading explanations"},
    {"goal": "Fix the build", "context": "Project root: /home/user/project"}
])

Jeder Subagent arbeitet unabhängig. Der übergeordnete Agent wartet auf alle und kombiniert dann die Ergebnisse.

Schritt 4: Die goldene Regel – Subagenten wissen nichts

Das ist der wichtigste Punkt, also aufgepasst:

Subagenten starten ohne jegliches Wissen über deine Konversation.

Wenn du sagst „Behebe den Fehler“, ohne zu erklären, was „der Fehler“ ist, ist der Subagent verloren. Du musst den gesamten nötigen Kontext in den Feldern goal und context übergeben.

Hier ist ein schlechtes Beispiel:

# SCHLECHT - der Subagent hat keine Ahnung, was "der Fehler" ist
delegate_task(goal="Fix the error")

Und die gute Version:

# GUT - der Subagent hat den gesamten benötigten Kontext
delegate_task(
    goal="Fix the TypeError in api/handlers.py",
    context="""The file api/handlers.py has a TypeError on line 47:
    'NoneType' object has no attribute 'get'.
    The function process_request() receives a dict from parse_body(),
    but parse_body() returns None when Content-Type is missing.
    The project is at /home/user/myproject and uses Python 3.11."""
)

Betrachte den context als ein Briefing-Dokument. Je spezifischer du bist, desto besser wird die Arbeit des Subagenten.

Schritt 5: Für reale Arbeitsabläufe nutzen

Parallele Recherche

Informationen zu mehreren Themen gleichzeitig sammeln:

delegate_task(tasks=[
    {
        "goal": "Research the current state of WebAssembly in 2025",
        "context": "Focus on: browser support, non-browser runtimes, language support"
    },
    {
        "goal": "Research the current state of RISC-V adoption in 2025",
        "context": "Focus on: server chips, embedded systems, software ecosystem"
    },
    {
        "goal": "Research quantum computing progress in 2025",
        "context": "Focus on: error correction breakthroughs, practical applications, key players"
    }
])

Code-Review + Fix

Einen kompletten Review-und-Fix-Auftrag an einen frischen Kontext übergeben:

delegate_task(
    goal="Review the authentication module for security issues and fix any found",
    context="""Project at /home/user/webapp.
    Auth module files: src/auth/login.py, src/auth/jwt.py, src/auth/middleware.py.
    The project uses Flask, PyJWT, and bcrypt.
    Focus on: SQL injection, JWT validation, password handling, session management.
    Fix any issues found and run the test suite (pytest tests/auth/)."""
)

Zusammenfassung

Subagent-Delegation ist dein Weg, um Arbeit in Hermes Agent zu parallelisieren. Denk an diese Kernpunkte:

Nutze delegate_task für eine einzelne Aufgabe oder eine Reihe von Aufgaben.
Gib immer vollständigen Kontext an – Subagenten starten bei null.
Standardmäßig bis zu 3 gleichzeitige Subagenten, konfigurierbar, falls du mehr brauchst.
Jeder Subagent gibt eine strukturierte Zusammenfassung zurück – was er getan hat, was er herausgefunden hat, geänderte Dateien, aufgetretene Probleme.

Es ist, als hättest du ein Team von Assistenten, die nur wissen, was du ihnen sagst – also sag ihnen alles, was sie brauchen.