Künstliche Intelligenz-Agenten durch die Gehirn-Hand-Analogie verstehen
Erfahren Sie, wie LLMs, Tools und Tool-Executor miteinander interagieren, indem Sie die Agent-Architektur an eine Analogie zum Bestellen von Essen anpassen, und erstellen Sie anschließend eine minimale Implementierung eines Agents.
Überblick
Sie sind wahrscheinlich schon auf Begriffe wie „Tool Calling“ gestoßen oder haben die Vorstellung, dass Agenten lediglich LLMs sind, die mit Tools verbunden sind. Anstatt direkt in Definitionen einzutauchen, verwendet dieser Artikel ein vertrautes Alltagsbeispiel, um zu erklären, was tatsächlich in einem KI-Agenten vor sich geht. Dabei werden Sie sehen, wie das LLM, die Tools sowie ein sogenannter Tool-Executor zusammenwirken. Dieser Text richtet sich an Entwickler, die die Mechanismen hinter einem Agenten wirklich verstehen möchten – anstatt nur die Fachbegriffe zu wiederholen – und später werden Sie Schritt für Schritt sehen, wie man einen minimalen Agenten erstellt, um die Umsetzung in der Praxis zu erleben.
Analogie
Stellen Sie sich vor, Sie bestellen Essen über eine Liefer-App. Wenn wir diese alltägliche Handlung durchgehen, wird klar, wie Ihr Gehirn und Ihre Finger mit der App zusammenarbeiten, um ein Essen zu bestellen. Anschließend werden wir jeden Schritt auf die Begriffe aus der Agenten-Theorie übertragen.
Zunächst gibt Ihr Gehirn Ihrem Finger den Befehl, die Essensbestell-App zu öffnen damit Sie nach Restaurants in der Nähe suchen können. Ihr Finger tippt auf das Icon, und eine Liste mit Restaurants erscheint auf dem Bildschirm.
Dann liest Ihr Gehirn die auf dem Bildschirm angezeigten Restaurantnamen durch und weist Ihren Finger an, auf ein bestimmtes Restaurant zu tippen, um dessen Menü anzuzeigen. Anschließend scannt Ihr Gehirn die Menüpunkte und gibt Ihrem Finger den Befehl, auf die Add-Taste neben den Gerichten zu tippen, die Sie möchten, um sie in den Warenkorb aufzunehmen.
Sobald das erledigt ist, überprüft Ihr Gehirn alles, was sich im Warenkorb befindet, um sicherzustellen, dass nichts fehlt, und weist Ihren Finger anschließend an, auf „Bestellung aufgeben“ zu tippen.
Schließlich erkennt Ihr Gehirn, dass das Ziel erreicht wurde, sobald es den Bestellbestätigungsbildschirm sieht, und zu diesem Zeitpunkt endet der Hin- und Herweg zwischen Gehirn und Finger.
Analogie in agenter Sprache
Bemerken Sie etwas Wichtiges in dieser gesamten Abfolge: Das Gehirn selbst hat niemals eine Aktion direkt ausgeführt – es interpretiert lediglich die eingehenden Informationen und weist den Finger an, was als Nächstes zu tun ist. Dies entspricht fast genau der Funktionsweise eines KI-Agenten. Das LLM übernimmt die Rolle des Gehirns; Aktionen wie das Durchsuchen von Restaurants, das Öffnen einer Speisekarte, das Hinzufügen von Artikeln zum Warenkorb und die Aufgabe der Bestellung sind die Werkzeuge, deren Nutzung das Gehirn kennt; und der Finger entspricht dem Werkzeugausführenden, dem Komponenten, der die Aktion tatsächlich ausführt.
Wenn man einen Agenten für einen bestimmten Zweck erstellt, definiert man eine Reihe von Werkzeugen und übergibt diese Liste an den LLM, der als Entscheidungsinstanz fungiert. (Ab jetzt wird -> verwendet, um anzuzeigen, dass der Kontrollfluss an den nächsten Schritt übergeht.) Wenn ein Benutzer dem Agenten eine Aufgabe zur Erledigung gibt, verläuft der Ablauf wie folgt: Der LLM prüft den aktuellen Schritt oder die noch ausstehende Arbeit und wählt das am relevantesten geeignete Werkzeug –> er übergibt dieses Werkzeug an den Ausführer, bittet ihn darum, es auszuführen und das Ergebnis zurückzugeben –> der LLM liest dieses Ergebnis und prüft, ob es den Anforderungen des Benutzers entspricht. Falls ja, endet der Prozess dort; falls nein, wählt der LLM auf Basis des neuesten Ergebnisses das nächstgeeignete Werkzeug und der Kreislauf beginnt erneut, bis der LLM feststellt, dass die Aufgabe vollständig erledigt ist und keine weiteren Werkzeugaufrufe mehr notwendig sind.
Implementierung
Sobald das Konzept feststeht, besteht der nächste Schritt darin, einen kleinen Funktionsagenten zu entwickeln, der in der Lage ist, eine Essensbestellung auf Basis der Anfrage des Benutzers aufzugeben. Die folgenden Codeausschnitte zeigen den tatsächlichen Ausführungspfad des Agenten, und am Ende ist ein Link zum vollständigen Repository enthalten.
Werkzeuge
get_restaurants() {
// In production, replace with an API call such as GET /api/v1/restaurants
return list of restaurants;
}
get_menu(restaurantName) {
// In production, replace with an API call such as GET /api/v1/restaurants/${restaurantName or restaurantId}/menu
return menuItems;
}
add_to_cart(sessionId, menuItemId) {
// In production, replace with an API call such as POST /api/v1/cart
return updatedCart;
}
place_order(sessionId) {
// In production, replace with an API call such as POST /api/v1/order
return orderDetails;
}
Bemerken Sie, dass es sich bei diesen Werkzeugen um nichts anderes als gewöhnliche Funktionen handelt, wie man sie in alltäglichen Anwendungscode schreibt – es sind keine speziellen Agentenframeworks oder lllm-spezifische Logiken in ihnen integriert. In einer echten Produktionsumgebung würde jedes Werkzeug außerdem einen Namen, eine Beschreibung sowie ein definiertes Eingabeschema enthalten, das angibt, welche Daten er erwartet. Genau auf diesen Namen und diese Beschreibung stützt sich das LLLM, um herauszufinden, welches Werkzeug am besten zu der Anfrage des Benutzers passt.
Werkzeugausführender
toolExecutor(toolCall) {
const tool = toolNameMap[toolCall.name];
return tool.execute(toolCall.arguments);
}
Der Tool-Executor selbst ist lediglich eine weitere gewöhnliche Funktion. Sein Argument toolCall enthält Informationen über das aufgerufene Tool – den Namen sowie seine Argumente – und diese variieren je nachdem, welches Tool aufgerufen wird, ob es sich um den Namen eines Restaurants, die ID eines Menüpunkts oder etwas ganz anderes handelt. Der entscheidende Punkt ist, dass der LLM dem Executor genau strukturierte Angaben mitgibt, wie zum Beispiel den Toolnamen get_menu zusammen mit dem Argument {restaurantName: "Spicy Pizza"}. Es ist nicht notwendig, diese Informationen manuell aus der rohen Textausgabe des LLMs zu extrahieren oder zu analysieren.
Agent
// Give all the tools to the LLM
llm = OpenAILLM.bindTools([get_restaurants, get_menu, add_to_cart, place_order])
// Take the user query to run the agent loop
reactAgent(userInput) {
while (true) {
response = llm(userInput);
if (response.isFinalAnswer) {
return response.answer;
}
result = toolExecutor(response.toolCall);
userInput = response + result;
}
}
Dinge, die man am Pseudocode beobachten kann
- Der Name
reactAgentbezieht sich auf das ReAct (Reason and Act)-Prompting-Muster, bei dem die LLM entscheidet, welches Tool aufgerufen werden soll, das Ergebnis dieser Aufrufung beobachtet und anschließend festlegt, ob ein weiteres Tool ausgeführt werden muss oder die Aufgabe abgeschlossen ist und der Loop beendet werden kann. - Achten Sie auf den
while(true)-Loop. Genau hier unterscheiden sich Agenten von der bedingten Logik, die man normalerweise in Sprachen wie Java oder Python schreibt. Anstatt Funktionsaufrufe direkt in if-else-Branches oder for-Schleifen einzubauen, stellt man einer LLM eine Reihe von Tools zur Verfügung – jeweils mit Namen und Beschreibung – und lässt die LLM selbst zur Laufzeit entscheiden, welches Tool als Nächstes aufgerufen werden soll, welche Argumente übergeben werden müssen und wann die Arbeit abgeschlossen ist und der Loop beendet werden sollte.
while(true)-Schleife beruhen; sie wird hier ausschließlich verwendet, um das zugrunde liegende agierende Verhalten in einfachem Code zu veranschaulichen. In der Praxis würde man auf ein Orchestrierungsframework wie LangGraph zurückgreifen. Selbst mit einem solchen Framework ist es übliche Praxis, die Rekursionstiefe zu begrenzen, damit der LLM nicht endlos aufgerufen werden kann – eine unbegrenzte Schleife birgt das Risiko von Fehlern, verschwendeten Tokens und unnötigen Kosten.response.isFinalAnswer im Pseudocode signalisiert, dass der Agent zu einer vollständigen Antwort gelangt ist und keine weiteren Toolaufrufe mehr erforderlich sind. Sobald dies der Fall ist, gibt der Agent dem Benutzer eine zusammengefasste Antwort zurück, anstatt ein weiteres Tool auszulösen.userInput = response + result aufgefallen, bei der die kombinierte Ausgabe in der nächsten Iteration als response = llm(userInput) erneut an das LLM übergeben wird. Dies liegt daran, dass jeder Aufruf des LLM zustandslos ist – es behält kein Gedächtnis an frühere Schritte, selbst innerhalb derselben Sitzung oder Benutzerinteraktion. Daher muss jedes Mal, wenn ein Tool seine Ausführung beendet hat, die gesamte Konversationshistorie erneut übermittelt werden: der Systemprompt, der beschreibt, wie sich das Agent verhalten soll, die ursprüngliche Benutzeranfrage, die vorherige Antwort der KI mit Vorschlag eines Toolaufrufs sowie das von diesem Tool erzeugte Ergebnis. Das LLM verarbeitet anschließend diese gesamte Abfolge, um zu beurteilen, ob das Ziel erreicht wurde oder weitere Toolaufrufe erforderlich sind.Ablaufdiagramm von LLM und Toolausführung
Das untenstehende Diagramm zeigt Schritt für Schritt, wie das LLM das nächste Tool auswählt, wie der Tool-Executor es ausführt und wie dieser Zyklus wiederholt wird, bis das LLM feststellt, dass die Aufgabe abgeschlossen ist und keine weitere Tool-Ausführung notwendig ist.
Der beschriebene Ablauf macht den Wechsel zwischen den Schritten klar sichtbar: Das LLM schlägt einen Aufruf vor, der Executor führt ihn aus, das Ergebnis gelangt zurück zum LLM, welches entweder einen weiteren Aufruf vorschlägt oder den Zyklus mit einer endgültigen Antwort beendet.
GitHub-Code
Falls Sie dieses Beispiel selbst ausprobieren und den Ablauf des Agents in Aktion beobachten möchten, steht ein Repository mit Starter-Code zur Verfügung.
Zusätzliche Literatur
- Verstehen von Elementen versus Nachrichten in OpenAI’s Responses API — Erklärt, wie OpenAI’s Responses API die Ausgaben des Modells in Elemente statt in Nachrichten umorganisiert und warum dieser Wandel für Tool-Aufrufe sowie agierende Workflows von Bedeutung ist.
- Verstehen von KI-Agenten: Ziele, Werkzeuge, Memorie und die Agent-Schleife — Eine für Anfänger geeignete Erklärung, wie sich KI-Agenten von Chatbots unterscheiden, mit Schwerpunkt auf den Kernkomponenten, der Entscheidungsschleife, den Autonomiegraden sowie praktischen Anwendungsfällen.