26. Juli 2026 · aktualisiert am 13. Oktober 2026

KI-Agent bauen: Anleitung mit Python, n8n und Claude

KI-Agent bauen: was ein Agent ist, welche Wege es gibt (n8n, Copilot Studio, SDKs) und ein lauffähiges Python-Beispiel mit Werkzeugen, Grenzen und Kosten.

KIAgentenLLM

Thema: KI & Coding

Inhalt (10 Abschnitte)

KI-Agent bauen: Anleitung mit Python, n8n und Claude

Einen KI-Agenten baust du aus drei Teilen: einem Sprachmodell, Werkzeugen, die es aufrufen darf, und einer Schleife, die Werkzeugaufrufe ausführt und die Ergebnisse zurückgibt, bis die Aufgabe erledigt ist. Ohne Code geht das mit n8n oder Copilot Studio, mit Code über die API eines Modellanbieters oder ein Agent-SDK. Ein lauffähiges Python-Beispiel steht unten.

Stand: 13. Oktober 2026. Funktionen, Befehle und Preise stammen aus den Dokumentationen von Anthropic, n8n, Microsoft, OpenAI und Ollama, abgerufen an diesem Tag. Die Quellen stehen am Ende.

Was ein KI-Agent ist und was nicht

Der Begriff wird für sehr verschiedene Dinge benutzt. Anthropic unterscheidet in seinem Leitfaden „Building effective agents“ zwei Arten von Systemen:

Workflows: Sprachmodell und Werkzeuge laufen auf vorher festgelegten Wegen im Code. Du bestimmst die Reihenfolge.
Agenten: Das Modell steuert selbst, welche Werkzeuge es in welcher Reihenfolge benutzt, und entscheidet, wann die Aufgabe fertig ist.

Daraus folgt die wichtigste Frage vor dem Bauen: Brauchst du überhaupt einen Agenten? Anthropic empfiehlt, die einfachste Lösung zu wählen und Komplexität nur hinzuzufügen, wenn sie nötig ist. Agentische Systeme tauschen laut dem Leitfaden oft Wartezeit und Kosten gegen bessere Ergebnisse. Für viele Anwendungen reicht ein einzelner, gut vorbereiteter Modellaufruf. Ein Agent lohnt sich, wenn sich die Zahl der Schritte nicht vorhersagen lässt und du keinen festen Weg programmieren kannst.

Die Wege im Überblick

Weg	Für wen	Programmieren nötig	Was du bekommst
n8n, Knoten „AI Agent“	Automatisierung mit vielen angebundenen Diensten	nein	Chatmodell plus Werkzeug-Knoten, das Modell wählt die Werkzeuge
Microsoft Copilot Studio	Unternehmen im Microsoft-Umfeld	nein (Low-Code)	Agenten aus Beschreibung in Alltagssprache, Anbindung an Daten der Organisation
API mit eigener Schleife (etwa Claude API)	Entwickler, die alles verstehen und steuern wollen	ja	volle Kontrolle über Werkzeuge, Grenzen und Ablauf
Claude Agent SDK	Entwickler, die einen Agenten mit Datei- und Kommandozeilenwerkzeugen brauchen	ja	die Werkzeuge und die Schleife von Claude Code als Bibliothek für Python und TypeScript
OpenAI Agents SDK	Entwickler im OpenAI-Umfeld	ja	Bibliothek mit Agenten, Werkzeugen, Übergaben zwischen Agenten, Guardrails und Tracing
Lokales Modell mit Ollama	Datenschutz, Experimente ohne laufende Kosten	ja	Werkzeugaufrufe mit offenen Modellen auf dem eigenen Rechner

n8n beschreibt seinen Agent-Knoten so: Du verbindest ein Chatmodell und mindestens ein Werkzeug, und der Agent entscheidet, welche Werkzeuge er aufruft. Die selbst betriebene Community Edition liegt auf GitHub. Die gehostete Fassung beginnt laut Preisseite beim Tarif Starter mit 20 € im Monat bei jährlicher Zahlung und 2.500 Ausführungen.

Copilot Studio nennt Microsoft ein grafisches Low-Code-Studio zum Erstellen und Verwalten von Agenten und Workflows. Einen Agenten legst du an, indem du ihn in Alltagssprache beschreibst und vor der Veröffentlichung testest.

Für Entwickler ist der Weg über die API nach Einschätzung der lehrreichste, weil er zeigt, was ein Agent technisch ist. Darum geht es im nächsten Abschnitt.

So funktioniert die Agent-Schleife

Werkzeugnutzung (auch „Function Calling“) läuft bei der Claude API laut Dokumentation in einem festen Ablauf:

Du schickst die Anfrage und eine Liste von Werkzeugen. Jedes Werkzeug hat einen Namen, eine Beschreibung und ein JSON-Schema für die Eingaben (input_schema).
Will das Modell ein Werkzeug benutzen, endet die Antwort mit stop_reason: "tool_use" und enthält einen oder mehrere tool_use-Blöcke mit Name und Eingaben.
Dein Code führt das Werkzeug aus und schickt das Ergebnis als tool_result-Block mit derselben tool_use_id zurück.
Das wiederholt sich, bis das Modell ohne Werkzeugaufruf antwortet.

Zwei Regeln aus der Dokumentation sind wichtig: Die tool_result-Blöcke müssen direkt auf die Nachricht mit den tool_use-Blöcken folgen, ohne Nachricht dazwischen. Und schlägt ein Werkzeug fehl, gibst du die Fehlermeldung als Inhalt zurück und setzt "is_error": true, statt den Aufruf zu verschweigen. So kann das Modell reagieren, etwa mit einem anderen Pfad.

Schritt für Schritt: ein Agent in Python

Das Beispiel baut einen kleinen Agenten, der Fragen zu einem Projektordner beantwortet. Er hat zwei Werkzeuge: Dateien auflisten und Dateien lesen. Beide sind auf den Projektordner beschränkt.

Voraussetzungen laut Dokumentation: Python 3.10 oder neuer, das Paket anthropic und ein API-Schlüssel in der Umgebungsvariable ANTHROPIC_API_KEY.

pip install anthropic
export ANTHROPIC_API_KEY=dein-schluessel

Der Agent als agent.py:

import pathlib
import anthropic

client = anthropic.Anthropic()  # liest den Schlüssel aus ANTHROPIC_API_KEY
WURZEL = pathlib.Path("./mein-projekt").resolve()
MAX_SCHRITTE = 10

tools = [
    {
        "name": "liste_dateien",
        "description": "Listet die Dateien und Ordner in einem Ordner des Projekts auf.",
        "input_schema": {
            "type": "object",
            "properties": {
                "ordner": {"type": "string", "description": "Pfad relativ zum Projekt, z. B. src"}
            },
            "required": ["ordner"],
        },
    },
    {
        "name": "lies_datei",
        "description": "Gibt den Inhalt einer Textdatei des Projekts zurück.",
        "input_schema": {
            "type": "object",
            "properties": {
                "pfad": {"type": "string", "description": "Pfad relativ zum Projekt"}
            },
            "required": ["pfad"],
        },
    },
]


def sicherer_pfad(relativ):
    pfad = (WURZEL / relativ).resolve()
    if not pfad.is_relative_to(WURZEL):
        raise ValueError("Pfad liegt außerhalb des Projekts")
    return pfad


def fuehre_aus(name, eingabe):
    if name == "liste_dateien":
        ordner = sicherer_pfad(eingabe["ordner"])
        return "\n".join(sorted(p.name for p in ordner.iterdir()))
    if name == "lies_datei":
        return sicherer_pfad(eingabe["pfad"]).read_text(encoding="utf-8")[:20000]
    raise ValueError(f"Unbekanntes Werkzeug: {name}")


messages = [{"role": "user", "content": "Wo wird in diesem Projekt die Datenbank konfiguriert?"}]

for schritt in range(MAX_SCHRITTE):
    response = client.messages.create(
        model="claude-opus-5-5",
        max_tokens=16000,
        tools=tools,
        messages=messages,
    )
    if response.stop_reason != "tool_use":
        break

    messages.append({"role": "assistant", "content": response.content})
    ergebnisse = []
    for block in response.content:
        if block.type != "tool_use":
            continue
        try:
            inhalt = fuehre_aus(block.name, block.input)
            ergebnisse.append({"type": "tool_result", "tool_use_id": block.id, "content": inhalt})
        except Exception as fehler:
            ergebnisse.append({"type": "tool_result", "tool_use_id": block.id,
                               "content": str(fehler), "is_error": True})
    messages.append({"role": "user", "content": ergebnisse})

print("".join(b.text for b in response.content if b.type == "text"))

Was die einzelnen Teile tun:

Werkzeugbeschreibungen: Das Modell entscheidet anhand von Name und Beschreibung, wann es ein Werkzeug benutzt. Klare Beschreibungen sind deshalb wichtiger als cleverer Code.
sicherer_pfad: Das Modell bestimmt die Eingaben. Jede Eingabe ist deshalb zu prüfen wie eine Benutzereingabe. Hier verhindert die Prüfung, dass der Agent Dateien außerhalb des Projekts liest.
MAX_SCHRITTE: Eine harte Obergrenze für die Schleife. Ohne sie kann ein Agent, der sich verrennt, beliebig viele Anfragen und damit Kosten erzeugen.
Alle Ergebnisse in einer Nachricht: Claude kann laut Dokumentation in einer Antwort mehrere Werkzeuge zugleich aufrufen. Die Ergebnisse gehen dann gesammelt in einer Nachricht zurück, wie es die Beispiele der Dokumentation zeigen.
Fehler als is_error: Der Agent erfährt, warum ein Aufruf scheiterte, und kann es anders versuchen.

Das Python-SDK bietet mit dem „Tool Runner“ zusätzlich eine Hilfsfunktion, die diese Schleife übernimmt. Sie ist laut Dokumentation als Beta gekennzeichnet. Die eigene Schleife oben hat den Vorteil, dass jeder Schritt sichtbar bleibt.

Mit dem Claude Agent SDK statt eigener Schleife

Brauchst du einen Agenten, der Dateien liest, bearbeitet und Befehle ausführt, musst du diese Werkzeuge nicht selbst schreiben. Das Claude Agent SDK stellt laut Dokumentation die Werkzeuge, die Schleife und die Kontextverwaltung von Claude Code als Bibliothek für Python und TypeScript bereit, dazu Hooks, Subagenten, MCP und Berechtigungen. Installation für Python:

pip install claude-agent-sdk

Ein Aufruf nach dem Schnellstart der Dokumentation:

import asyncio
from claude_agent_sdk import query, ClaudeAgentOptions, AssistantMessage, ResultMessage


async def main():
    async for message in query(
        prompt="Review utils.py for bugs that would cause crashes. Fix any issues you find.",
        options=ClaudeAgentOptions(
            allowed_tools=["Read", "Edit", "Glob"],
            permission_mode="acceptEdits",
        ),
    ):
        if isinstance(message, AssistantMessage):
            for block in message.content:
                if hasattr(block, "text"):
                    print(block.text)
        elif isinstance(message, ResultMessage):
            print(f"Done: {message.subtype}")


asyncio.run(main())

allowed_tools legt fest, welche Werkzeuge ohne Rückfrage laufen, permission_mode="acceptEdits" erlaubt Änderungen an Dateien. Für eigene Produkte verlangt Anthropic die Anmeldung per API-Schlüssel; die Anmeldung mit einem Claude-Abo ist für Drittanbieter ohne vorherige Freigabe nicht erlaubt. Wie du Claude Code selbst installierst, steht in der Anleitung Claude Code installieren.

Lokal und ohne laufende Kosten: Ollama

Werkzeugaufrufe funktionieren auch mit offenen Modellen auf dem eigenen Rechner. Ollama unterstützt laut Dokumentation Tool Calling über seine lokale Schnittstelle unter http://localhost:11434/api/chat, die Beispiele dort nutzen das Modell qwen3. Die Schleife ist dieselbe wie oben: Werkzeuge mitschicken, Aufrufe ausführen, Ergebnisse zurückgeben. Welche Hardware ein lokales Modell braucht, erklärt der Ratgeber Lokale KI.

Was ein Agent kostet

Bei einem Agenten über die API zahlst du pro Token. Die Preise von Anthropic für die aktuellen Modelle:

Modell	Eingabe je Million Token	Ausgabe je Million Token	Eingabe aus dem Cache
Claude Fable 5.1	10 $	50 $	0,25 $
Claude Opus 5.5	4 $	20 $	0,20 $
Claude Sonnet 5.5	2 $	10 $	0,10 $
Claude Haiku 5.5 (Anfragen bis 100.000 Token)	0,10 $	0,50 $	0,01 $

Drei Dinge machen Agenten teurer als einzelne Anfragen. Erstens zählen die Werkzeugdefinitionen, die tool_use- und die tool_result-Blöcke als Token. Zweitens fügt die API bei Werkzeugnutzung einen eigenen Systemprompt hinzu, bei Opus 5.5, Sonnet 5.5 und Haiku 5.5 laut Dokumentation 286 Token je Anfrage. Drittens schickt die Schleife bei jedem Schritt den gesamten bisherigen Verlauf erneut, und jede Anfrage wird mit allen gesendeten Eingabe-Token abgerechnet. Ein Agent mit zehn Schritten zahlt den Anfang des Gesprächs also zehnmal. Prompt-Caching senkt diesen Teil, weil wiederholte Eingaben zum Cache-Preis abgerechnet werden. Mehr dazu im Artikel über LLM-Kosten im Griff.

Grenzen und Sicherheit

Anthropic weist im Leitfaden darauf hin, dass die Selbstständigkeit von Agenten höhere Kosten und sich aufschaukelnde Fehler mit sich bringt, und empfiehlt ausgiebige Tests in abgeschotteten Umgebungen und passende Schutzmaßnahmen. Für den Bau folgen daraus diese Punkte:

Risiko	Gegenmaßnahme
Schleife ohne Ende	feste Obergrenze für Schritte und Kosten
Werkzeug mit zu viel Macht	nur die nötigen Werkzeuge, Pfade und Rechte freigeben
gefährliche Aktionen (Löschen, Zahlen, Senden)	Bestätigung durch einen Menschen vor der Ausführung
Eingaben vom Modell	wie Benutzereingaben prüfen
Fehler bleiben unbemerkt	jeden Werkzeugaufruf mit Eingabe und Ergebnis protokollieren

Der Leitfaden hält es außerdem für entscheidend, dass der Agent in jedem Schritt eine verlässliche Rückmeldung aus seiner Umgebung bekommt, etwa Ergebnisse von Werkzeugaufrufen oder Code-Ausführung, um seinen Fortschritt einzuschätzen. Bei einem Coding-Agenten sind das zum Beispiel Testergebnisse.

Quellen und Stand

Alle Angaben wurden am 13. Oktober 2026 geprüft an:

Häufige Fragen

Kann ich einen KI-Agenten kostenlos bauen?

Ja, mit Einschränkungen. Die Community Edition von n8n lässt sich selbst betreiben, und mit Ollama laufen Werkzeugaufrufe mit offenen Modellen auf dem eigenen Rechner ohne Gebühren je Anfrage. Wer ein Modell über eine API nutzt, zahlt pro Token, bei Claude Haiku 5.5 etwa 0,10 $ je Million Eingabe-Token.

Wie baue ich einen KI-Agenten mit n8n?

Du fügst in einem Workflow den Knoten „AI Agent“ ein, verbindest ein Chatmodell und mindestens ein Werkzeug als Unterknoten. Laut n8n entscheidet der Agent dann selbst, welche Werkzeuge er aufruft. Ohne Werkzeug funktioniert der Knoten nicht. Seit n8n 1.82.0 arbeiten alle Agent-Knoten als „Tools Agent“.

Kann ich mit Claude einen KI-Agenten erstellen?

Ja, auf zwei Wegen. Über die Claude API definierst du eigene Werkzeuge und schreibst die Schleife selbst, wie im Beispiel oben. Mit dem Claude Agent SDK bekommst du die Werkzeuge und die Schleife von Claude Code als Bibliothek für Python und TypeScript. Für eigene Produkte brauchst du in beiden Fällen einen API-Schlüssel.

Wie erstelle ich einen KI-Agenten mit Copilot?

Mit Microsoft Copilot Studio. Microsoft beschreibt es als grafisches Low-Code-Studio für Agenten und Workflows. Du beschreibst den Agenten in Alltagssprache, verbindest ihn mit Wissensquellen und Werkzeugen und testest ihn vor der Veröffentlichung.

Welche Programmiersprache brauche ich für einen KI-Agenten?

Keine bestimmte. Die Schleife besteht aus HTTP-Anfragen und lässt sich in jeder Sprache schreiben. Das Claude Agent SDK gibt es für Python und TypeScript, das Agents SDK von OpenAI unter anderem für Python.

Was ist der Unterschied zwischen einem Chatbot und einem KI-Agenten?

Ein Chatbot antwortet auf Nachrichten. Ein Agent benutzt zusätzlich Werkzeuge und entscheidet selbst, welche er in welcher Reihenfolge aufruft, bis eine Aufgabe erledigt ist. Anthropic grenzt Agenten außerdem von Workflows ab, bei denen der Ablauf im Code festgelegt ist.