Agenten bauen

Ein KI-Agent ist ein Programm, das eine Aufgabe in mehreren Schritten selbst erledigt. Es bekommt ein Ziel, entscheidet, welcher Schritt als Nächstes sinnvoll ist, benutzt dafür Werkzeuge (etwa einen Kalender, eine Kundendatei oder das Postfach), schaut sich das Ergebnis an und macht weiter, bis die Aufgabe erledigt ist oder ein Mensch gefragt werden muss.

Das klingt nach Zukunft, ist aber heute mit überschaubarem Aufwand machbar. Diese Seite zeigt, wann sich ein Agent lohnt, wie er aufgebaut ist und wie ihr den ersten baut, einmal ohne Programmieren und einmal mit ein paar Zeilen Code.

Was einen Agenten ausmacht

OpenAI beschreibt in seinem Leitfaden von 2025 einen Agenten als System, das Aufgaben eigenständig im Auftrag erledigt, selbst merkt, wann es fertig ist, und bei Problemen an den Menschen zurückgibt. Google hat 2024 in seinem Whitepaper drei Bausteine herausgearbeitet, die sich überall wiederfinden:

• Das Modell ist der Kopf. Es versteht die Aufgabe, plant und formuliert.
• Die Werkzeuge sind die Hände. Damit liest der Agent Daten, schreibt Entwürfe, legt Termine an oder fragt andere Systeme ab.
• Die Anweisungen sind die Arbeitsbeschreibung: was der Agent tun soll, was er auf keinen Fall darf und wann er fragt.

Dazu kommt eine Schleife: denken, handeln, nachsehen, wieder denken. Google nennt dieses Muster ReAct (aus „Reasoning” und „Acting”). Genau diese Schleife unterscheidet einen Agenten von einem Chat, der nur antwortet.

Workflow oder Agent

Die wichtigste Entscheidung fällt vor dem Bauen. Anthropic unterscheidet in seinem viel gelesenen Beitrag „Building effective agents” (2024) zwei Arten:

• Im Workflow (fester Ablauf) bestimmt ihr die Schritte. Die KI übernimmt einzelne Teile, etwa eine Mail einordnen oder eine Rechnung auslesen. Der Weg ist immer derselbe.
• Im Agenten bestimmt das Modell die Schritte selbst. Es entscheidet, welches Werkzeug es wann benutzt und wie oft.

Der Rat von Anthropic und OpenAI ist derselbe, und wir teilen ihn: Fangt mit der einfachsten Lösung an. Ein fester Ablauf ist billiger, schneller, leichter zu prüfen und reicht in den meisten Fällen. Ein Agent lohnt sich dort, wo der Weg jedes Mal anders aussieht:

• bei Ermessensentscheidungen, etwa ob eine Reklamation berechtigt ist und welche Lösung passt,
• bei Regelwerken, die kaum noch jemand überblickt, etwa die Prüfung neuer Lieferanten,
• bei viel unstrukturiertem Material, etwa Schadensmeldungen mit Fotos, Mails und Gesprächsnotizen.

Eine gute Faustregel: Wenn ihr den Ablauf auf ein Blatt zeichnen könnt, baut einen Workflow. Wenn das Blatt voller Verzweigungen ist, die sich jedes Mal ändern, denkt über einen Agenten nach.

Die fünf Muster

Zwischen ganz festem Ablauf und ganz freiem Agenten liegen fünf bewährte Muster, die Anthropic beschrieben hat. Wir erklären sie mit Beispielen aus dem Mittelstand:

1. Kette mit Prüfpunkten (Prompt Chaining): Schritte folgen fest aufeinander, dazwischen wird geprüft. Angebot entwerfen, gegen die Preisliste prüfen, dann übersetzen.
2. Weiche (Routing): Ein Eingang wird eingeordnet und an den richtigen Spezialisten gegeben. Das Service-Postfach sortiert in Reklamation, Bestellung, Frage und Bewerbung, einfache Fälle gehen an ein günstiges Modell, schwierige an ein starkes.
3. Gleichzeitig arbeiten (Parallelisierung): Teilaufgaben laufen nebeneinander, oder mehrere Durchläufe stimmen ab. Ein Modell schreibt die Antwort, ein zweites prüft gleichzeitig, ob vertrauliche Daten darin stehen.
4. Vorarbeiter und Helfer (Orchestrator-Workers): Ein zentrales Modell zerlegt eine große Aufgabe und verteilt sie. Für eine Ausschreibung liest ein Helfer die Unterlagen, einer sucht passende Referenzen, einer rechnet, der Vorarbeiter fügt zusammen.
5. Schreiben und Prüfen im Wechsel (Evaluator-Optimizer): Ein Modell erzeugt, ein zweites bewertet und gibt Rückmeldung, bis das Ergebnis passt. Ein Social-Media-Beitrag wird so lange überarbeitet, bis er euren Stilregeln entspricht.

Oft reicht eines dieser Muster, und ihr braucht gar keinen freien Agenten.

Werkzeuge und MCP

Ein Agent ist nur so gut wie seine Werkzeuge. Anthropic hat 2025 beschrieben, worauf es dabei ankommt: Werkzeuge brauchen klare Namen, eine verständliche Beschreibung und sollten so gebaut sein, dass Fehler schwer zu machen sind. Statt „Datenbank abfragen” lieber „Kunde nach Kundennummer suchen”. Ein Werkzeug, das nur liest, ist harmloser als eines, das schreibt, löscht oder Geld bewegt.

Damit nicht jeder Agent jedes Werkzeug neu anbinden muss, gibt es MCP, das Model Context Protocol. Anthropic hat es 2024 als offenen Standard vorgestellt, inzwischen liegt es bei einer Stiftung unter dem Dach der Linux Foundation. Ihr könnt euch MCP wie eine Steckdosenleiste vorstellen: Ein Werkzeug wird einmal als MCP-Server angeschlossen, danach können verschiedene KI-Programme es nutzen. Für viele bekannte Dienste gibt es solche Server schon.

Eine Warnung gehört dazu: Ein MCP-Server kann versteckte Anweisungen in seiner Beschreibung tragen, die das Modell befolgt, ohne dass ein Mensch sie sieht. Die Sicherheitsfirma Invariant Labs hat das 2025 als „Tool Poisoning” (vergiftetes Werkzeug) gezeigt. Darum gilt: nur geprüfte Server, jedes Werkzeug mit den geringsten nötigen Rechten, und Folgenreiches immer mit Freigabe.

Mensch in der Schleife

„Mensch in der Schleife” heißt: An festgelegten Stellen hält der Agent an und fragt. Das ist der wichtigste Schutz, den ihr habt. Bewährt hat sich eine einfache Einteilung der Werkzeuge nach Risiko:

• Lesen (Kundendaten ansehen, Kalender prüfen): darf der Agent allein.
• Entwerfen (Mail, Angebot, Termin vorbereiten): darf der Agent allein, das Ergebnis bleibt ein Entwurf.
• Senden, Buchen, Löschen, Bezahlen: nur nach Freigabe durch einen Menschen.

Dazu kommen Abbruchregeln: höchstens eine bestimmte Zahl an Schritten, ein Budget je Lauf, und bei Unsicherheit lieber fragen als raten. OpenAI empfiehlt außerdem Schutzschichten (Guardrails) vor und nach dem Modell, etwa Filter gegen eingeschleuste Befehle in Mails oder Dokumenten. Dieses Einschleusen heißt Prompt Injection und steht bei der Sicherheitsorganisation OWASP auf Platz eins der Risiken für KI-Anwendungen (2025). Es lässt sich nach heutigem Stand nicht vollständig verhindern. Umso wichtiger ist, dass der Agent gar nicht erst die Rechte hat, großen Schaden anzurichten.

Im Kundenkontakt braucht es außerdem immer einen Weg zum Menschen, und seit August 2026 muss sich ein KI-System, das mit Menschen spricht, als KI zu erkennen geben (Art. 50 AI Act).

Testen mit Beispielfällen

Ein Agent geht erst in Betrieb, wenn er getestet ist. Getestet wird mit Beispielfällen (in der Fachsprache Evals): einer Liste echter oder nachgestellter Aufgaben mit dem Ergebnis, das ihr erwartet.

So geht ihr vor:

1. Sammelt 30 typische Fälle aus dem Alltag, darunter fünf schwierige und fünf, bei denen der Agent ablehnen oder nachfragen soll.
2. Schreibt zu jedem Fall auf, was richtig wäre.
3. Lasst den Agenten alle Fälle durchlaufen und vergleicht.
4. Ändert ihr später etwas an Anweisungen, Werkzeugen oder Modell, läuft der ganze Katalog erneut.

Google beschreibt in seinem „Agents Companion” (2025), dass man nicht nur die Endantwort bewerten sollte, sondern auch den Weg: Hat der Agent die richtigen Werkzeuge in sinnvoller Reihenfolge benutzt? Eine zweite KI kann beim Bewerten helfen, sollte aber regelmäßig von Menschen überprüft werden.

Kosten im Griff

Agenten rechnen mit Rechenzeit, und die kostet je Lauf. Ein Agent, der zwanzig Schritte macht, kostet ein Vielfaches eines einfachen Chats. Vier Stellschrauben halten das im Rahmen:

• Das passende Modell je Aufgabe: einfache Einordnung mit einem kleinen, günstigen Modell, schwierige Entscheidungen mit einem großen. OpenAI rät, zuerst mit dem stärksten Modell die Messlatte zu legen und dann zu prüfen, wo ein kleineres reicht.
• Grenzen setzen: höchste Zahl an Schritten und ein Budget je Lauf.
• Messen: Jeder Lauf wird protokolliert, mit Dauer, Schritten und Kosten. Werkzeuge wie Langfuse aus Berlin lassen sich dafür selbst auf einem Server in der EU betreiben.
• Wenig Ballast: Nur die Informationen mitgeben, die der Agent für diese Aufgabe braucht. Kürzere Eingaben sind günstiger und führen oft zu besseren Ergebnissen.

Schritt für Schritt: der erste Agent ohne Code mit n8n

n8n ist ein Werkzeug aus Berlin, mit dem man Abläufe per Maus zusammenklickt. Es lässt sich selbst auf einem Server in der EU betreiben oder in der Cloud in Frankfurt nutzen und hat einen eigenen Baustein für KI-Agenten. Unser Beispiel: ein Agent, der Terminanfragen im Postfach beantwortet.

1. Auslöser anlegen: ein Baustein, der neue Mails im Postfach „Anfragen” abholt.
2. Agent-Baustein einfügen und ein Sprachmodell anbinden, am besten über einen Anbieter mit Rechenzentrum in der EU.
3. Anweisung schreiben: „Du beantwortest Terminanfragen für unseren Betrieb. Du schlägst drei freie Termine vor, schreibst freundlich und kurz in der Sie-Form. Bei Reklamationen, Preisfragen oder Unklarem schreibst du keinen Entwurf, sondern markierst die Mail für einen Menschen.”
4. Werkzeuge anschließen: den Kalender (nur lesen) und das Postfach (nur Entwürfe anlegen).
5. Freigabe einbauen: Bevor eine Mail rausgeht, bekommt eine Person den Entwurf mit den Knöpfen „Senden” und „Ändern”. n8n bietet dafür Bausteine, die anhalten und auf eine Antwort warten.
6. Grenzen setzen: höchstens fünf Schritte je Mail, bei Fehlern eine Nachricht an die Verantwortliche.
7. Testen: 30 alte Anfragen durchlaufen lassen und die Entwürfe mit dem vergleichen, was ihr damals geschrieben habt.
8. Eine Woche im Schattenbetrieb: Der Agent schreibt mit, gesendet wird weiter von Hand. Danach entscheidet ihr, ob er übernimmt.

Für das Angebot von Dienstleistern wichtig: Die freie Ausgabe von n8n darf man für eigene Abläufe und für Abläufe bei Kunden frei nutzen. Sollen Kunden selbst im n8n eines Dienstleisters arbeiten, braucht es eine eigene Lizenz.

Schritt für Schritt: der erste Agent mit Code

Wer etwas programmieren kann, versteht mit einem kleinen eigenen Agenten am besten, was darunter passiert. Anthropic rät ausdrücklich, Frameworks (fertige Baukästen) erst zu nutzen, wenn man das Prinzip verstanden hat. Das Prinzip passt auf eine halbe Seite.

1. Werkzeug beschreiben: Ihr legt fest, wie es heißt, was es tut und welche Angaben es braucht.
2. Schleife bauen: Das Modell bekommt Aufgabe und Werkzeuge. Möchte es ein Werkzeug benutzen, führt euer Programm es aus und gibt das Ergebnis zurück. Das wiederholt sich, bis das Modell fertig ist.
3. Grenze setzen: Nach einer festen Zahl von Runden ist Schluss.

So sieht das in Python mit der Programmierschnittstelle von Anthropic aus. Das Werkzeug sucht in einer kleinen Liste nach einem Artikel im Lager:

import anthropic

client = anthropic.Anthropic()  # liest den Schlüssel aus der Umgebung
MODELL = "hier-das-gewuenschte-modell"

LAGER = {"Schraube M8": 1200, "Dübel 10 mm": 40}

werkzeuge = [{
    "name": "lagerbestand",
    "description": "Gibt den Lagerbestand eines Artikels zurück.",
    "input_schema": {
        "type": "object",
        "properties": {"artikel": {"type": "string"}},
        "required": ["artikel"],
    },
}]

verlauf = [{"role": "user",
            "content": "Reichen Schrauben M8 und Dübel 10 mm für 300 Halterungen mit je 2 Stück?"}]

for runde in range(5):  # Grenze: höchstens fünf Runden
    antwort = client.messages.create(model=MODELL, max_tokens=1024,
                                     tools=werkzeuge, messages=verlauf)
    verlauf.append({"role": "assistant", "content": antwort.content})
    if antwort.stop_reason != "tool_use":
        print(antwort.content[0].text)
        break
    ergebnisse = []
    for teil in antwort.content:
        if teil.type == "tool_use":
            bestand = LAGER.get(teil.input["artikel"], 0)
            ergebnisse.append({"type": "tool_result",
                               "tool_use_id": teil.id,
                               "content": str(bestand)})
    verlauf.append({"role": "user", "content": ergebnisse})

Das Modell fragt beide Bestände ab, rechnet nach und antwortet, dass die Schrauben reichen und die Dübel fehlen. Von hier aus wachsen eure Agenten: echte Werkzeuge statt der Liste, ein Testkatalog, ein Protokoll je Lauf, eine Freigabe vor jedem Schreibzugriff. Für den Betrieb gibt es fertige Baukästen der großen Anbieter, die genau diese Schleife sauber umsetzen.

Gesprächsfragen für den Termin

• Welche Aufgabe bei euch braucht jedes Mal mehrere Schritte und mehrere Programme?
• Ließe sie sich als fester Ablauf zeichnen, oder sieht sie jedes Mal anders aus?
• Welche Daten müsste ein Agent lesen, und was dürfte er auf keinen Fall verändern?
• Wer gibt bei euch frei, bevor etwas nach außen geht?
• Habt ihr 30 Beispielfälle, an denen ihr einen Agenten testen könnt?
• Wer schaut sich die Protokolle an, wenn der Agent läuft?