Agenten erklärt: Werkzeuge, Systemanfragen und der Gedanken-Handlungszyklus
Einführung für Anfänger dazu, wie KI-Agenten funktionieren: Warum Chat-Modelle vergessen, wie Tools einem LLM beschrieben werden, Systemanweisungen, ReAct, Code-Agenten und Beobachtungen.
Moderne KI-Agenten basieren auf einer begrenzten Anzahl von Prinzipien: Werkzeuge, ein Systemprompt sowie ein wiederkehrender Zyklus aus Denken, Handeln und Beobachten. Sobald diese Elemente zusammenwirken, ähneln die meisten Agenten-Frameworks Variationen desselben Konzepts. Die folgenden Abschnitte erläutern das Thema Schritt für Schritt, beginnend mit der Definition dessen, was ein Agent eigentlich ist.
Was ein Agent ist
Ein Agent ist ein System, in dem ein KI-Modell mit seiner Umgebung zusammenarbeitet, um eine bestimmte Aufgabe zu erledigen. Dabei werden Vernunftdenken, Planung sowie die Ausführung von Aktionen – meist über externe Werkzeuge – miteinander verbunden. Die meisten Agenten werden von einem LLM angetrieben, obwohl auch ein Vision-Language-Modell dieselbe Funktion übernehmen kann.
Ihre Chat-App vergisst alles
Es gibt eine Tatsache, die viele Menschen überrascht: Wenn Sie mit ChatGPT oder einem ähnlichen Assistenten chatten, findet innerhalb des Modells keine Konversation statt. Es speichert nichts, verfolgt keinen laufenden Zustand und behält nichts zwischen Ihren Nachrichten. Jedes Mal, wenn Sie auf „Senden“ klicken, wird der gesamte bisherige Austausch zu einem langen Textblock zusammengefügt, und das Modell liest diesen Block von Anfang an.
Bilden Sie sich diesen Austausch vor:
conversation = [
{"role": "user", "content": "I need help with my order"},
{"role": "assistant", "content": "Could you provide your order number?"},
{"role": "user", "content": "It's ORDER-123"},
]
Eine übersichtliche Liste der Schritte mit den zugehörigen Rollen ist das, was man sieht und was Entwickler im Code handhaben. Das Modell erhält jedoch niemals eine solche Liste. Bevor irgendetwas bei ihm ankommt, werden die Schritte vereinfacht und zu einer einzigen Textsequenz zusammengefügt; seine einzige Aufgabe, wie immer, besteht darin, anhand aller vorherigen Informationen das nächste Token vorherzusagen.
Es gibt keinen speziellen „das merken“-Schritt. Wenn das Modell Ihren Bestellnummern zu erinnern scheint, handelt es sich dabei nicht um Gedächtnisfunktionen. Die Nummer befindet sich einfach weiterhin im Text, den es zu diesem Zeitpunkt liest.
Tools
Ein Tool ist eine Funktion, idealerweise mit einem klaren Zweck, die an das LLM übergeben wird. Typische Beispiele sind:
- Das Surfen im Internet
- Die Erstellung von Bildern
- Das Abrufen von Dokumenten
- Der Aufruf einer API
Ein gutes Tool erweitert die Fähigkeiten des Modells. Es benötigt folgende Bestandteile:
- eine textliche Beschreibung dessen, was die Funktion tut
Wie ein Tool tatsächlich aufgerufen wird
Der entscheidende Punkt ist, dass ein LLM keine externen Tools direkt nutzen kann. Der Text wird eingegeben und als Text wieder ausgegeben – nichts weiter. Wenn man sagt, ein Modell „habe Zugriff auf Tools“, bedeutet das eigentlich nur, dass es gelernt hat, einen Toolaufruf in Textform niederzuschreiben. Wenn man nach dem Wetter in Paris fragt, holt das Modell keinen Wettervorhersage-Text ab. Stattdessen gibt es eine strukturierte Nachricht aus, in der angegeben wird, dass das Wetter-Tool gestartet werden soll.
Eine Agenteschicht befindet sich zwischen dem Benutzer und dem Modell. Sie erkennt die Nachricht, führt das Tool aus, sammelt das Ergebnis ein und fügt es der Konversation hinzu, bevor sie alles wieder an das Modell sendet. Mit diesem zusätzlichen Kontext erstellt das Modell eine normale Antwort. Der Benutzer hat den Eindruck, als hätte das Modell direkt mit dem Wetterdienst kommuniziert, obwohl der Agent die gesamte Koordination im Hintergrund übernommen hat.
Ein kleines Beispiel
Zur Veranschaulichung nehmen wir ein Rechenwerkzeug, das nur eine Aufgabe erfüllt: die Multiplikation zweier Ganzzahlen.
def multiply(a:int, b:int):
"Multiply two integers"
return a * b
Eine Funktion in ein Tool umwandeln
Die Hugging Face transformers-Bibliothek bietet einen @tool-Decorator, der eine gewöhnliche Python-Funktion umhüllt, damit ein Agent sie verstehen kann. Zuerst kommt die Import-Anweisung:
from transformers import tool
Dann die dekorierte Funktion:
@tool
def multiply(a: int, b: int):
"""Multiply two integers."""
return a * b
Hinter den Kulissen sammelt der Dekorator Metadaten:
- den Namen der Funktion
- ihrer Beschreibung
- die Namen der Argumente
- die Typen der Argumente
- den Rückgabetyp
Diese Metadaten werden später in die Anweisung aufgenommen, die dem Modell mitteilt, wie es das Tool korrekt verwenden soll.
Ein Tool betrachten
Nach der Dekoration kann sich ein Tool in Text beschreiben:
print(multiply.to_string())
Die ausgegebene Ausgabe enthält Informationen in dieser Art:
Tool Name: multiply
Description:
Multiply two integers.Arguments:
- a (int)
- b (int)
Diese strukturierte Beschreibung ist genau das, was der Agent dem Modell zeigt. Das LLM liest sie wie jeden anderen Text und entscheidet, ob das Tool bei der Bearbeitung des Anliegens des Benutzers hilfreich ist.
Der agierende Arbeitsablauf
Ein Agent arbeitet in einem wiederholten Zyklus: Er denkt (Thought), handelt (Action) und beobachtet anschließend (Observation).
- Thought. Der LLM-Anteil des Agents entscheidet, was als Nächstes getan werden soll.
- Action. Der Agent ruft die Tools mit den ausgewählten Argumenten auf.
- Observation. Das Modell prüft, was das Tool zurückgegeben hat.
Der Agent bleibt in diesem Zyklus aus Denken, Handeln und Beobachten, bis sein Ziel erreicht ist.
Der Systemprompt
Ein Systemprompt ist eine Reihe von Anweisungen, die einem Modell vor jeder Benutzernachricht übermittelt werden. Er legt das Verhalten, die Rolle, Einschränkungen und Ziele für den gesamten Dialog fest.
Wenn ein Benutzer etwas schreibt, sieht das Modell mehr als nur diesen Text. In der Regel erhält es etwas in dieser Form:
<System Prompt>
You are a helpful programming assistant.
Always explain concepts before showing code.
If the user asks for unsafe code, refuse politely.
<User>
Explain binary search.
Der Systemhinweis hat Vorrang vor dem Hinweis des Benutzers. Angenommen, es wird angegeben, dass stets auf Englisch geantwortet werden soll, und der Benutzer bittet um eine Antwort auf Französisch. In der Regel wird das Modell dem Systemhinweis folgen, es sei denn, die Anwendung erlaubt ausdrücklich, dass Benutzeranfragen diesen überschreiben.
Der Systemhinweis eines Agenten geht noch weiter und beschreibt die Tools sowie den Prozess selbst:
You are an AI assistant that can answer user questions.
You have access to the following tools:
Tool: search_web
Description:
Searches the web for up-to-date information.
Arguments:
- query (string)
Tool: calculator
Description:
Evaluates mathematical expressions.
Arguments:
- expression (string)
If a user's question requires current information, use search_web.
If a calculation is required, use calculator.
Otherwise, answer directly.
Drei Aspekte werden in dieser Systemnachricht definiert:
- wie sich der Agent verhalten soll
- welche Tools er verwenden kann, wie im vorherigen Abschnitt beschrieben
- der Thought-Action-Observation-Zyklus, der in die Anweisungen des Modells integriert ist
Jeder dieser drei Aspekte verdient eine genaue Betrachtung.
Gedanken
Gedanken erfassen das interne Denken und Planen des Agents während der Erledigung einer Aufgabe. Zwei gängige Ansätze sind:
- Chain-of-Thought (CoT)
- ReAct (Denken plus Handeln)
Chain-of-Thought ist eine Anreizmethode, die ein Modell dazu bringt, ein Problem Schritt für Schritt zu durchdenken, bevor es eine endgültige Antwort gibt. Das Denken bleibt intern, was für Logik- und Mathematikaufgaben geeignet ist, die keine externen Tools benötigen.
ReAct ist eine Methode, die ebenfalls schrittweises Denken erfordert, aber zwischen den Überlegungsschritten auch Aktionen wie Toolaufrufe einbaut.
Sowohl Ansätze ermöglichen es einem LLM, Probleme schrittweise zu durchdenken. Der Unterschied besteht darin, dass CoT nur von dem abhängt, was das Modell bereits weiß, während ReAct Denken mit Aktionen verbindet. Dadurch kann das Modell externe Tools nutzen, aktuelle Informationen sammeln und sein Denken an den Ergebnissen ausrichten – was besser zu dynamischen, realweltlichen Aufgaben passt, die externe Systeme betreffen.
Aktionen: vom Denken zum Handeln
Aktionen sind die Schritte, die ein Agent unternimmt, um mit seiner Umgebung zu interagieren. Ein Kundenservice-Agent könnte beispielsweise Kundendaten abrufen, Support-Artikel vorschlagen oder einen Fall an einen Menschen weiterleiten.
Ein Textgenerator kann mithilfe eines einfachen Musters namens „Stoppen und Analysieren“ echte Tools auslösen. Das Modell führt selbst nie etwas aus. Es erzeugt eine strukturierte Anfrage, die beschreibt, was geschehen soll, und der Agent führt diese im Auftrag des Modells aus.
Im Grunde handelt es sich dabei um denselben Zyklus wie zuvor. Das Modell überlegt sich die Aufgabe, gibt eine Aktion wie einen Aufruf einer Wetter-API aus und stoppt anschließend. Der Agent erkennt die Aktion, ruft das entsprechende Tool auf und gibt das Ergebnis als Beobachtung zurück. Mit dieser Information setzt das Modell entweder seine Überlegungen fort, ergreift eine weitere Aktion oder gibt die endgültige Antwort ab.
Historisch gesehen wurden Aktionen als Funktionsaufrufe oder JSON-Objekte dargestellt, die ein Tool sowie seine Argumente benannten. Das funktioniert zwar, wird aber unpraktisch, wenn ein Workflow viele Toolaufrufe erfordert. Code-Agenten gehen einen anderen Weg: Anstatt Aktionen in JSON zu beschreiben, erstellt das Modell ausführbaren Python-Code. Schleifen, Bedingungen, Variablen sowie mehrere Toolaufrufe können dann einen Codeblock teilen, was für komplexe Aufgaben ausdrucksstärker und effizienter ist.
Die traditionelle JSON-Form sieht so aus:
{
"tool": "get_weather",
"arguments": {"location": "Tokyo"}
}
Ein Code-Agent schreibt stattdessen einen ausführbaren Codeausschnitt:
# The agent writes actual Python code as its action
cities = ["Tokyo", "Paris", "New York", "London", "Sydney"]
temps = [get_weather(city) for city in cities]
avg_temp = sum(temps) / len(temps)
print(f"Average temperature: {avg_temp}")
Beobachtungen: Feedback zu jeder Aktion
Logisches Denken und Handeln bilden nur die Hälfte der Geschichte. Nach dem Handeln muss ein Agent das Ergebnis verstehen – und genau dafür dient eine Beobachtung: das Feedback, das nach Ausführung einer Aktion eingeholt wird. Es kann sich um ein Suchergebnis im Internet, eine API-Antwort, die Ausgabe eines Python-Programms oder sogar eine Fehlermeldung handeln. Was auch immer es ist, es wird zu neuen Informationen für die Auswahl des nächsten Schritts.
Der Ablauf ist einfach. Der Agent führt eine Aktion aus, das Framework setzt sie um und fügt die Ausgabe als Beobachtung zur Konversation hinzu. Das LLM liest den aktualisierten Kontext und setzt seine Arbeit fort. Mit ausreichenden Informationen gibt es die endgültige Antwort. Andernfalls plant es eine weitere Aktion.
Beobachtungen müssen nicht unbedingt erfolgreich sein. Wenn ein Aufruf fehlschlägt – sei es durch eine 404 Not Found-Meldung von einem Endpunkt oder einen Python TypeError im generierten Code – ist dieser Fehler dennoch wertvoll. Die Fehlermeldung zeigt dem Agenten, was schiefgelaufen ist, sodass er mit seiner nächsten Aktion den Fehler korrigieren kann, anstatt ihn zu wiederholen.
Diese kontinuierliche Schleife macht Agenten anpassungsfähig. Anstatt sich nur auf vortrainiertes Wissen zu verlassen, sammeln sie neue Fakten, lernen aus den Ergebnissen und verfeinern ihren Ansatz, bis die Aufgabe erledigt ist.
Die Komponenten zusammenfügen
Agenten mögen wie ein völlig neues Paradigma erscheinen, doch sie entstehen aus der Kombination einiger einfacher Ideen. Ein Sprachmodell überlegt sich eine Lösung für ein Problem, ein Systemprompt prägt sein Verhalten, Tools erweitern seine Funktionalitäten über den Text hinaus, Aktionen verbinden es mit der Außenwelt und Beobachtungen liefern Feedback, damit es sich anpassen kann.
Die Grundlagen zu verstehen und zu erkennen, wie wenig „Magie“ in jedem dieser Bausteine steckt, ist der erste Schritt zur Erstellung eigener Agenten. Coding-Assistenten, Forschungskopiloten sowie autonome Arbeitsabläufe stützen sich alle auf denselben Zyklus aus Denken, Handeln und Beobachten. Der natürliche nächste Schritt ist es dann, mit dem Hugging Face Ökosystem einen ersten Agenten umzusetzen.