So baust du deinen ersten KI-Agenten: ein Modell, ein paar Tools und eine Schleife

„KI-Agent" klingt, als bräuchte es ein Framework, eine Vektordatenbank und ein Wochenende Setup. Tut es aber nicht. Anthropics eigene Definition ist erfrischend knapp: Ein Agent ist ein LLM, das autonom in einer Schleife Tools nutzt. Sobald man das Muster erkannt hat, kann man einen brauchbaren ersten Agenten in deutlich unter hundert Codezeilen bauen – und, ebenso wichtig, weiß, wann man es nicht tun sollte.

Die Kernschleife

Jeder Agent, egal wie ausgefeilt, ist derselbe vierstufige Zyklus:

1. Du gibst dem Modell ein Ziel und eine Liste von Tools, die es aufrufen darf.
2. Das Modell entscheidet, ob es direkt antwortet oder ein Tool aufruft.
3. Dein Code führt das Tool aus und gibt das Ergebnis an das Modell zurück.
4. Wiederhole, bis das Modell sagt, dass es fertig ist.

Das Modell berührt niemals selbst dein Dateisystem oder Netzwerk. Es bittet nur jemals darum, ein Tool auszuführen; dein Code entscheidet, ob und wie es tatsächlich geschieht. In dieser Lücke lebt deine gesamte Sicherheit.

Ein konkretes Beispiel

Hier ist ein minimaler Agent, der Fragen mithilfe eines Taschenrechner-Tools beantworten kann. Worauf es ankommt, ist die Struktur – dieselbe Form skaliert auf Dateibearbeitung, Websuche oder Datenbankabfragen.

import anthropic

client = anthropic.Anthropic()

tools = [{
    "name": "calculator",
    "description": "Evaluate a basic arithmetic expression and return the result.",
    "input_schema": {
        "type": "object",
        "properties": {"expression": {"type": "string"}},
        "required": ["expression"],
    },
}]

def run_tool(name, args):
    if name == "calculator":
        # In real code, use a safe parser, not eval()
        return str(eval(args["expression"], {"__builtins__": {}}))
    return "unknown tool"

messages = [{"role": "user", "content": "What is 1894 * 37 plus 12?"}]

while True:
    resp = client.messages.create(
        model="claude-sonnet-4-6",
        max_tokens=1024,
        tools=tools,
        messages=messages,
    )
    messages.append({"role": "assistant", "content": resp.content})

    if resp.stop_reason != "tool_use":
        print(resp.content[0].text)
        break

    tool_results = []
    for block in resp.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": "user", "content": tool_results})

Diese while-Schleife ist der Agent. Das Modell sieht die Frage, bittet darum, calculator mit "1894 * 37 + 12" aufzurufen, dein Code führt das aus, gibt 70090 zurück, und das Modell schreibt die endgültige Antwort. Ersetze den Taschenrechner durch ein read_file/write_file-Paar, und du hast einen primitiven Coding-Agenten.

Die Tools sind der Teil, auf den es wirklich ankommt

Das Modell ist nur so leistungsfähig wie die Tools, die du ihm gibst, und das Design der Tools ist es, woran die meisten ersten Agenten scheitern. Anthropics Leitfaden zum Schreiben von Tools für Agenten lässt sich auf einige wenige Regeln herunterbrechen:

• Benenne und beschreibe Tools, als würdest du für einen neuen Teamkollegen schreiben. search_invoices(customer_id, date_range) schlägt ein vages query(sql) – je klarer der Vertrag, desto weniger Fehlaufrufe.
• Liefere aussagekräftige Ergebnisse, keine Rohdaten-Dumps. Wenn ein Tool 5.000 Zeilen JSON zurückgibt, hast du gerade das Kontextbudget des Modells für Rauschen verbraucht. Kürze auf das, was nützlich ist.
• Mache Fehler lehrreich. „File not found: did you mean config.yaml?" lässt das Modell sich erholen; ein nackter Stack-Trace tut das meist nicht.

Schutzmechanismen, bevor du ihn loslässt

Weil dein Code jeden Tool-Aufruf ausführt, trägst du die Verantwortung für die Sicherheit. Drei Schutzmechanismen, die du hinzufügen solltest, bevor ein Agent etwas Echtes berührt:

• Begrenze die Schleife. Füge eine maximale Iterationszahl hinzu, damit ein verwirrter Agent nicht ewig kreisen kann (und eine Rechnung in die Höhe treibt).
• Sichere destruktive Aktionen ab. Alles, was löscht, sendet oder bezahlt, sollte eine Bestätigung erfordern oder zunächst gegen eine Sandbox laufen.
• Validiere Tool-Eingaben. Wende niemals eval() auf nicht vertrauenswürdige Strings an und leite Modell-Ausgaben niemals direkt in eine Shell. Behandle jedes Tool-Argument als nicht vertrauenswürdige Benutzereingabe – denn faktisch ist es genau das.

Wann du KEINEN Agenten bauen solltest

Das Nützlichste, was man früh lernen sollte: Viele Probleme brauchen überhaupt keinen Agenten. Wenn die Schritte im Voraus bekannt sind – Daten abrufen, zusammenfassen, die Zusammenfassung per E-Mail versenden –, ist ein schlichtes Skript mit ein oder zwei Modellaufrufen günstiger, schneller und einfacher zu debuggen. Anthropic nennt diese Workflows und empfiehlt sie immer dann, wenn der Weg vorhersehbar ist. Greife nur dann zu einem echten Agenten, wenn das Modell wirklich entscheiden muss, was als Nächstes zu tun ist, basierend auf dem, was es vorfindet.

Beginne mit der obigen vierstufigen Schleife, gib ihr ein oder zwei gut beschriebene Tools, begrenze die Iterationen und füge eine echte Aufgabe hinzu. Du lernst mehr aus einem funktionierenden Agenten als aus noch so viel Framework-Dokumentation.