Tutorial 25: Code-Ausführung | Easy Understand Hermes Agent

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

Stell dir vor, du backst einen Kuchen und anstatt die Zutaten einzeln zu holen, schreibst du das ganze Rezept auf, gibst es einem Helfer, und der bringt dir nur den fertigen Kuchen zurück. Genau das macht Code Execution für Hermes Agent – es lässt den Agenten ein komplettes Python-Skript ausführen, das mehrere Tools intern aufruft und dann nur das Endergebnis an die Konversation zurückgibt.

Was ist Code Execution?

Normalerweise, wenn Hermes das Web durchsuchen, eine Datei lesen oder einen Befehl ausführen muss, macht es jeden Schritt einzeln – und jedes Zwischenergebnis wird in seinen “Speicher” (das Kontextfenster) geladen. Das ist langsam und verschwendet Tokens.

Mit dem execute_code-Tool schreibt Hermes ein Python-Skript, das Tools programmatisch aufrufen kann – wie web_search, read_file oder patch – alles auf einen Schlag. Das Skript läuft in einem separaten Kindprozess, und nur die print()-Ausgabe kommt zum Agenten zurück. Alle unübersichtlichen Zwischendaten bleiben verborgen.

So funktioniert’s: Schritt für Schritt

Schritt 1: Der Agent schreibt ein Python-Skript
Es beginnt damit, Tools aus einem speziellen Modul zu importieren:

from hermes_tools import web_search, web_extract

Schritt 2: Hermes erstellt ein Helfer-Modul
Es generiert automatisch einen hermes_tools.py-Stub, der dein Skript mit dem Haupt-Agenten verbindet.

Schritt 3: Ein Kommunikationskanal wird geöffnet
Hermes öffnet einen Unix-Domain-Socket (eine schnelle, lokale “Telefonleitung” zwischen Prozessen) und startet einen Listener-Thread.

Schritt 4: Das Skript läuft in einem Kindprozess
Jeder Tool-Aufruf in deinem Skript wandert über diesen Socket zurück zu Hermes, der ihn ausführt und das Ergebnis zurückschickt.

Schritt 5: Nur die Print-Ausgabe kommt zurück
Die print()-Anweisungen des Skripts sind das einzige, was das LLM sieht. Alle Zwischenergebnisse der Tools gelangen nie ins Kontextfenster – das spart massiv Tokens.

Wann nutzt Hermes das?

Der Agent wählt automatisch execute_code, wenn er Folgendes erkennt:

3 oder mehr Tool-Aufrufe mit Logik dazwischen (wie Filtern oder Vergleichen)
Massenhafte Datenverarbeitung – z. B. viele Dateien durchsuchen und Ausschnitte extrahieren
Schleifen – eine Aktion auf viele Elemente anwenden

Der große Vorteil? Token-Effizienz. Anstatt jedes Suchergebnis zurück in die Konversation zu füttern, kommt nur die finale Zusammenfassung durch.

Praktische Beispiele zum Ausprobieren

1. Datenverarbeitungs-Pipeline

from hermes_tools import search_files, read_file
import json

# Finde alle Konfigurationsdateien und extrahiere Datenbankeinstellungen
matches = search_files("database", path=".", file_glob="*.yaml", limit=20)
configs = []
for match in matches.get("matches", []):
    content = read_file(match["path"])
    configs.append({"file": match["path"], "preview": content["content"][:200]})

print(json.dumps(configs, indent=2))

2. Mehrstufige Web-Recherche

from hermes_tools import web_search, web_extract
import json

results = web_search("Rust async runtime comparison 2025", limit=5)
summaries = []
for r in results["data"]["web"]:
    page = web_extract([r["url"]])
    for p in page.get("results", []):
        if p.get("content"):
            summaries.append({
                "title": r["title"],
                "url": r["url"],
                "excerpt": p["content"][:500]
            })

print(json.dumps(summaries, indent=2))

3. Massenhaftes Datei-Refactoring

from hermes_tools import search_files, read_file, patch

matches = search_files("old_api_call", path="src/", file_glob="*.py")
fixed = 0
for match in matches.get("matches", []):
    result = patch(
        path=match["path"],
        old_string="old_api_call(",
        new_string="new_api_call(",
        replace_all=True
    )
    if "error" not in str(result):
        fixed += 1

print(f"Fixed {fixed} files out of {len(matches.get('matches', []))} matches")

4. Build- und Test-Pipeline

from hermes_tools import terminal
import json

result = terminal("cd /project && python -m pytest --tb=short -q 2>&1", timeout=120)
output = result.get("output", "")

passed = output.count(" passed")
failed = output.count(" failed")

print(json.dumps({"passed": passed, "failed": failed}, indent=2))

Wichtige Punkte zum Merken

Verfügbare Tools in Skripten: web_search, web_extract, read_file, write_file, search_files, patch und terminal (nur Vordergrund).
Nur print()-Ausgabe kommt zurück – alles andere bleibt verborgen.
Ideal für Schleifen, Filtern und mehrstufige Workflows – es ist, als würdest du Hermes eine Mini-Programmierumgebung geben.

Zusammenfassung

Code Execution verwandelt Hermes von einem Schritt-für-Schritt-Assistenten in einen Stapelverarbeiter. Es schreibt ein Skript, führt es aus und gibt dir nur die endgültige Antwort – das spart Zeit, Tokens und kognitive Belastung. Wenn du jemals siehst, dass Hermes viele sich wiederholende Tool-Aufrufe macht, nutzt es wahrscheinlich diese Funktion im Hintergrund.