Was ein Agent wirklich ist

Du hast API-Aufrufe gemacht, aber ein einzelner Aufruf gibt nur eine Antwort zurück. Wenn du einen Workflow automatisieren möchtest, muss Claude handeln, das Ergebnis betrachten, entscheiden, was als nächstes kommt, und weitermachen. Dieses Muster ist das, was Menschen meinen, wenn sie von agentic workflows sprechen.

Ein Agent ist eine autonome Version von Claude, die beide Seiten der Messaging-Schleife ohne einen Menschen in der Mitte ausführt. Ein Agent erhält eine Aufgabe, wählt ein Tool aus und führt Code in einer Schleife aus, bis Claude entscheidet, dass die Aufgabe erledigt ist.

Die einfachste Möglichkeit, eine Agent-Schleife zu implementieren, sieht so aus:

Sende eine Nachricht an Claude mit verfügbaren Tools.
Claude antwortet entweder mit einer endgültigen Antwort oder einer Anfrage, ein von dir definiertes Tool zu verwenden.
Dein Code führt dieses Tool aus.
Du sendest das Ergebnis zurück an Claude.
Wiederhole, bis der stop reason end_turn ist.

Stell dir das als ein Gespräch vor, bei dem sich die Züge abwechseln: Der Benutzer startet, der Agent ruft ein Tool auf, das Tool gibt ein Ergebnis zurück, und der Agent macht weiter, bis er eine Antwort hat.

Ein minimales funktionierendes Beispiel

Um diese Schleife von Anfang bis Ende auszuführen, ohne eine Datenbank oder eine Benutzeroberfläche einzubeziehen, verbinden wir ein gefälschtes Tool namens get_weather und fragen Claude, was man heute in Austin anziehen sollte. Claude kann das Wetter nicht von selbst kennen, also muss es das Tool aufrufen, das Ergebnis lesen und dir dann eine Antwort geben.

Hier ist das ganze Skript:

import anthropic

client = anthropic. Anthropic()

tools = [ { "name": "get_weather", "description": "Get the current weather for a city. ", "input_schema": { "type": "object", "properties": { "city": { "type": "string", "description": "The city to get weather for", } }, "required": ["city"], }, } ]

def run_tool(name, tool_input): if name == "get_weather": return f"Weather in {tool_input['city']}: 95F, sunny" raise ValueError(f"Unknown tool: {name}")

messages = [ {"role": "user", "content": "What should I wear in Austin today? "} ]

while True: response = client. messages. create( model="claude-sonnet-4-6", max_tokens=1024, tools=tools, messages=messages, )

if response. stop_reason == "end_turn":

for block in response. content: if block. type == "text": print(block. text) break

if response. stop_reason == "tool_use":

tool_results = [] for block in response. content: if block. type == "tool_use": result = run_tool(block. name, block. input) tool_results. append( { "type": "tool_result", "tool_use_id": block. id, "content": result, } )

messages. append({"role": "assistant", "content": response. content}) messages. append({"role": "user", "content": tool_results})

Drei Dinge zu beachten:

Das Tools-Array sagt Claude, was verfügbar ist: ein Name, eine Beschreibung und ein JSON-Schema für die Eingaben.
run_tool ist nur eine hardcodierte Nachschlagung. In einer echten App würde dies deine Datenbank, eine API oder ähnliches aufrufen.
Die Schleife ist die Agent-Schleife. Jede Iteration sendet die Nachrichten an Claude und wechselt basierend auf dem stop reason der Antwort. Bei end_turn ist Claude fertig — gib den endgültigen Text aus und unterbreche. Bei tool_use finde die Tool-Use-Blöcke, führe jeden aus, schiebe die Antwort des Assistenten und deine Tool-Ergebnisse zurück in messages, und schleife erneut, damit Claude antworten kann.

Ausführung

Wenn du das Skript ausführst, siehst du zwei Züge:

Zug eins: Der stop reason ist tool_use. Claude fordert get_weather für Austin an, und dein Code gibt die Temperatur und Bedingungen zurück.
Zug zwei: Der stop reason ist end_turn, und Claude sagt dir, etwas Leichtes und Atmungsaktives anzuziehen.

Terminal-Ausgabe der Agent-Schleife: Zug 1 stoppt mit tool_use und ruft get_weather für Austin auf, dann stoppt Zug 2 mit end_turn und Claude gibt seine endgültigen Kleidungsempfehlungen aus

Zwei API-Aufrufe, eine Tool-Ausführung, eine endgültige Antwort. Das ist die gesamte Schleife. Alles, was du mit der Claude API erstellst, wird diesem ähnlich sein.

Die gleiche Schleife in der Produktion

In einer echten Umgebung treibt diese gleiche Schleife etwas wie einen Auto-Review-Endpunkt an: einen Compliance-Agent, der einen Strukturbericht liest, die relevanten Bauvorschriften über ein Tool nachschlägt und Risikofeststellungen nacheinander in die Datenbank schreibt, während er arbeitet.

Ein Compliance-Review-Dashboard mit hochgeladenen Strukturberichten, jeder mit einer Schaltfläche „Auto-Review ausführen", die den Agent startet

Die Form der Schleife ist identisch mit dem, was du gerade ausgeführt hast. Die Unterschiede sind:

Echte Tools statt einer Mock-Wetter-Nachschlagung.
Ergebnisse werden als Server-Sent Events zurück zur Benutzeroberfläche gestreamt.
Feststellungen werden in einer Risikofeststellungstabelle persistiert.

Die Review-Spur eines laufenden Compliance-Agenten: Dutzende von Tool-Aufrufen, die die Bauvorschriftsbibliothek durchsuchen und spezifische Codeabschnitte nachschlagen, während die Schleife iteriert

Zusammenfassung

Ein Agent ist Claude in einer Schleife: beobachten, entscheiden, handeln, wiederholen.
Die Schleife ist einfach: Sende Nachrichten mit Tools, führe alle Tools aus, die Claude anfordert, gib das Ergebnis zurück, und stoppe, wenn der stop reason end_turn ist.
Du besitzt die Schleife und die Tools. Claude besitzt das Reasoning.
Die gleiche Schleifenform skaliert von einer Mock-Wetter-Demo zu einem Production-Compliance-Agent — nur die Tools und die Infrastruktur ändern sich.
Wenn du die Schleife nicht selbst verwalten möchtest, führen verwaltete Agenten diese exakte Schleife für dich auf der Infrastruktur von Anthropic aus.