Sichere KI-Agenten: So führen Sie unsicheren Code aus ohne Server-Desaster

Die Vision von autonomen KI-Agenten, die selbstständig Aufgaben erledigen, klingt verlockend: Sie analysieren Daten, führen Befehle aus und optimieren Workflows – ohne menschliches Eingreifen. Doch diese Freiheit birgt ein enormes Risiko. Ein einziger Fehler in der Logik oder eine missverstandene Anweisung kann ausreichen, um das gesamte System zu kompromittieren.

Nehmen wir ein Szenario, das Entwickler fürchten: Ein KI-Agent erhält den Auftrag, temporäre Dateien in einem Projektverzeichnis zu bereinigen. Doch statt harmloser Befehle wie rm -rf tmp/ generiert die KI aufgrund eines Parsing-Fehlers oder einer Halluzination den Befehl `rm -rf /` – und löscht binnen Sekunden das gesamte Dateisystem. Solche Katastrophen sind kein Science-Fiction-Szenario, sondern eine reale Bedrohung in der Ära agentischer KI.

Die Lösung liegt nicht darin, der KI weniger Freiheit zu geben, sondern darin, ihre Werkzeuge und Ausführungsmechanismen so zu gestalten, dass sie zwar mächtig, aber gleichzeitig kontrollierbar bleibt. Der Hermes-Agent (Version 0.13) demonstriert, wie eine solche Architektur funktioniert – durch eine Kombination aus Zustandsmaschinen, dynamischer Sandboxierung und policybasierten Sicherheitsmechanismen.

Vom statischen Tool zur dynamischen Zustandsmaschine

In traditionellen Softwarearchitekturen sind Tools feste Funktionen in Bibliotheken: Dokumentiert, versioniert und von Entwicklern manuell aufgerufen. Doch autonome KI-Agenten brechen mit diesem Modell. Hier ist das Tool nicht nur ein Werkzeug, sondern eine Schnittstelle zu einem externen Zustand – eine Datei wird geschrieben, ein Befehl ausgeführt, eine Datenbank aktualisiert. Jede Aktion der KI verändert damit den Zustand der Umgebung.

Um diese Dynamik sicher zu steuern, muss das Tool als Zustandsmaschine modelliert werden. Der Hermes-Agent implementiert dies durch einen kontinuierlichen Loop aus drei Phasen:

• Wahrnehmung (Perception): Die KI empfängt Benutzereingaben oder Tool-Ergebnisse.
• Kognition (Cognition): Das Sprachmodell verarbeitet die Eingabe und generiert eine Antwort – oder einen Tool-Aufruf.
• Aktion (Action): Die KI führt den Tool-Aufruf aus und integriert das Ergebnis zurück in den Kontext.

Dieser Loop ähnelt einem geschlossenen Regelkreis, in dem jede Aktion sofort zur nächsten Entscheidung führt. Doch ohne Kontrollmechanismen kann dieser Prozess außer Kontrolle geraten – etwa wenn die KI in eine Endlosschleife gerät oder ungewollt Systembefehle ausführt.

Die dreistufige Sicherheitsarchitektur des Hermes-Agenten

Hermes löst dieses Problem durch eine hierarchische, versionierte und policygesteuerte Architektur, die in drei Schichten unterteilt ist. Jede Schicht übernimmt eine spezifische Sicherheitsfunktion, um die Ausführung unkontrollierter Aktionen zu verhindern.

1. Die Tool-Definitions-Schicht: Der Katalog der Möglichkeiten

Diese Schicht definiert welche Tools der KI überhaupt zur Verfügung stehen – und wie sie genutzt werden dürfen. Jedes Tool wird durch ein JSON-Schema beschrieben, das Name, Beschreibung und strikte Vorgaben für die Parameter enthält. Diese Schemata werden an das Sprachmodell übermittelt, um ihm klar zu kommunizieren, welche Aktionen es ausführen kann.

Ein Beispiel aus der Implementierung zeigt, wie ein Tool für die Dateiverwaltung definiert ist:

class FileToolSchema(BaseModel):
    action: Literal["read", "write", "delete"]
    path: str
    content: Optional[str] = None

Durch diese strenge Typisierung und Dokumentation wird verhindert, dass die KI Parameter missversteht oder unerwartete Aktionen ausführt.

2. Die Tool-Ausführungs-Schicht: Der Dispatcher mit Fehlerabwehr

Sobald die KI einen Tool-Aufruf generiert, übernimmt diese Schicht die Validierung und Ausführung. Sie fungiert als zentraler Dispatcher, der die Anfrage an den richtigen Handler weiterleitet. Dabei werden folgende Schritte durchlaufen:

• Argumentvalidierung: Die Parameter werden gegen das Schema geprüft.
• Typumwandlung: Rohdaten werden in die erwarteten Datentypen konvertiert.

• Fehlerabfang: Syntaxfehler oder ungültige Pfade werden abgefangen, bevor sie Schaden anrichten.

Diese Schicht stellt sicher, dass selbst wenn die KI fehlerhafte Anweisungen generiert, diese frühzeitig erkannt und abgeblockt werden.

3. Die Sandboxing-Schicht: Der letzte Schutzschild

Die tiefste Sicherheitsstufe ist die Sandbox, die gefährliche Operationen wie Shell-Befehle oder Code-Ausführung streng isoliert. Hermes nutzt hier mehrere Ansätze:

• Docker-Container: Kritische Tools laufen in isolierten Umgebungen, die keine Systemdateien oder Netzwerkzugriffe außerhalb des Containers erlauben.
• Checkpoints und Rollbacks: Vor jeder riskanten Aktion wird ein Snapshot des Systems erstellt. Bei Fehlern kann der Zustand zurückgesetzt werden.
• Benutzerbestätigungen: Für besonders sensible Aktionen (z. B. Löschen von Dateien) ist eine manuelle Freigabe erforderlich.

Diese Layer bilden gemeinsam ein mehrstufiges Sicherheitsnetz, das selbst bei schwerwiegenden Fehlern der KI eine Katastrophe verhindert.

Der run_conversation-Loop: Ein sich selbst korrigierendes System

Im Kern des Hermes-Agenten steht die Methode `run_conversation`, die den gesamten Interaktionsprozess steuert. Sie funktioniert wie eine Zustandsmaschine mit Feedbackschleife, die sicherstellt, dass die KI aus ihren Aktionen lernt.

Hier ein vereinfachter Ablauf des Loops:

def run_conversation(self, user_message, ...):
    # Initialisierung: Kontext und Gedächtnis laden
    messages = [...]  # Start mit Benutzereingabe
    
    while api_call_count < max_iterations:
        # 1. Phase: API-Aufruf an das LLM
        response = self._interruptible_api_call(api_kwargs)
        assistant_message = self._build_assistant_message(response)
        
        # 2. Phase: Tool-Ausführung prüfen
        if assistant_message.tool_calls:
            # Tool-Ergebnisse als neue Nachrichten speichern
            messages.append(assistant_message)
            
            # Tools sequenziell oder parallel ausführen
            self._execute_tool_calls(assistant_message, messages)
            
            # Schleife fortsetzen, um Tool-Ergebnisse zu verarbeiten
            continue
        
        # 3. Phase: Finale Antwort generieren
        break

Jeder Tool-Aufruf wird als neue Nachricht in der Konversation gespeichert. Das bedeutet: Die KI sieht das Ergebnis ihrer Aktion sofort und kann darauf reagieren – entweder durch eine weitere Tool-Ausführung oder durch die finale Antwort.

Dieses Design macht den Agenten nicht nur mächtiger, sondern auch selbstkorrigierend. Wenn die KI beispielsweise versucht, eine Datei zu löschen, die nicht existiert, wird das Fehlerergebnis zurückgegeben und die KI kann eine alternative Lösung vorschlagen. Ohne diese Feedbackschleife wäre die KI auf reine Spekulation angewiesen.

Fazit: Die Zukunft agentischer KI liegt in kontrollierter Autonomie

Die Ära der KI-Agenten hat gerade erst begonnen, doch die Herausforderungen sind enorm. Unkontrollierte Ausführung von Code, Endlosschleifen oder ungewollte Systemänderungen sind keine theoretischen Risiken, sondern reale Gefahren. Frameworks wie Hermes zeigen jedoch, dass diese Probleme nicht durch Einschränkung, sondern durch intelligente Architektur gelöst werden können.

Die Kombination aus Zustandsmaschinen, mehrschichtigem Sandboxing und dynamischer Tool-Definition ermöglicht es Entwicklern, KI-Agenten zu bauen, die nicht nur mächtig, sondern auch sicher sind. Der Schlüssel liegt darin, der KI genug Freiheit zu geben, um nützlich zu sein – aber gleichzeitig genug Kontrolle, um Katastrophen zu verhindern. Mit solchen Ansätzen wird die agentische KI nicht nur ein Werkzeug, sondern ein vertrauenswürdiger Partner in der digitalen Welt.