KI-Agenten: Der Komplettkurs

Alle Welt redet 2026 über KI-Agenten.

Die meisten haben keine Ahnung, wie sie wirklich funktionieren.

Das ändert sich heute.

Ich habe Wochen damit verbracht, alles zu destillieren: Kurse, Bücher, echte Builds, Produktionsfehler.

Hier ist, was du wirklich wissen musst.

Ob du deinen eigenen Workflow automatisierst oder KI-Systeme für ein Unternehmen baust – das hier ist deine Roadmap.

Speicher dir das. Es ist lang. Es lohnt sich.

TEIL 1: EINSTEIGER Was KI-Agenten eigentlich sind

1. Was ist ein KI-Agent?

Ein normales LLM macht eine Sache:

Du fragst. Es antwortet. Fertig.

Ein Schuss. Linear. Keine Iteration.

Ein KI-Agent arbeitet anders.

Er arbeitet so, wie du tatsächlich an schwierigen Aufgaben arbeitest:

→ Erst planen → Recherchieren → Entwurf → Eigene Arbeit prüfen → Überarbeiten → Wiederholen

Das nennt sich der ReAct-Loop:

Überlegen → Handeln → Beobachten → Wiederholen

Das Modell überlegt, was als Nächstes zu tun ist. Handelt (normalerweise durch Aufruf eines Tools). Beobachtet das Ergebnis. Dann gibt es dir entweder die Antwort oder geht zurück in die Schleife.

Warum ist das wichtig?

Jeder Durchlauf bringt mehr Tiefe. Stärkeres Denken. Weniger Halluzinationen. Bessere Organisation.

Alles, was du verlierst, wenn du es auf einen Schlag versuchst – Agenten holen es zurück.

2. Wofür sind Agenten eigentlich gut?

Nicht jede Aufgabe braucht einen Agenten.

Das richtige mentale Modell: eine 2×2-Matrix.

Achsen: Komplexität vs. benötigte Präzision.

→ Niedrige Komplexität + hohe Präzision = einfach Code verwenden → Niedrige Komplexität + niedrige Präzision = einfach einen einzelnen LLM-Prompt verwenden → Hohe Komplexität + hohe Präzision = Agenten mit starken Schutzmaßnahmen (Steuerformulare, Rechtsdokumente) → Hohe Komplexität + niedrige Präzision = optimaler Einstiegspunkt

Dieses letzte Quadrant ist dein schnellster erster Erfolg.

Beispiele für perfekte Agentenaufgaben:

→ Recherchieren und einen Bericht schreiben

→ Auf Kunden-E-Mails antworten (Bestellung nachschlagen → Antwort entwerfen)

→ Rechnungen verarbeiten

→ in Datenbank speichern

→ "Hast du blaue Jeans unter 80€?" beantworten, indem du tatsächlich den Bestand prüfst

Agenten glänzen, wenn die Aufgabe erfordert:

→ Mehrere Schritte

→ Externe Informationen

→ Iteration und Selbstkorrektur

Wenn du es mit einem Prompt lösen kannst – baue keinen Agenten.

3. Das Autonomie-Spektrum

Die erste große Entscheidung beim Bau eines Agenten:

Wie viel Kontrolle gibst du ihm?

Stell dir ein Spektrum vor.

Skriptgesteuert (linkes Ende)

Du programmierst jeden Schritt fest.

→ Suchbegriffe generieren → Websuche aufrufen → Seiten abrufen → Aufsatz schreiben.

Das Modell macht nur Textgenerierung. Du entscheidest alles andere. Vorhersagbar. Leicht zu debuggen. Begrenzt.

Halbautonom (Mitte)

Der Agent wählt aus von dir definierten Tools. Er trifft Entscheidungen innerhalb von dir gesetzten Leitplanken. Hier leben die meisten echten Produktionssysteme.

Vollständig autonom (rechtes Ende)

Das LLM entscheidet alles. Wonach gesucht wird. Wie viele Seiten abgerufen werden. Ob reflektiert wird. Ob neuer Code geschrieben und ausgeführt wird. Leistungsstärker. Viel schwerer zu kontrollieren.

Wo solltest du anfangen?

Mitte des Spektrums. Gib ihm Tools. Setze Leitplanken. Füge Autonomie nur hinzu, wenn du Vertrauen gewonnen hast.

4. Context Engineering

Hier ist, was einen Agenten wirklich "intelligent" macht.

Es ist nicht das Modell allein.

Es ist der Kontext, den du um ihn herum aufbaust.

Context Engineering = entscheiden, welche Informationen der Agent zu jedem Zeitpunkt hat.

Dazu gehört:

→ Hintergrund – was ist die Aufgabe, wer ist der Benutzer

→ Rolle – "du bist ein Recherche-Agent, spezialisiert auf Marktanalyse"

→ Gedächtnis – was ist in vorherigen Schritten passiert

→ Verfügbare Tools – welche Funktionen kann es aufrufen

→ Wissen – Dokumente, Datenbanken, PDFs, auf die es verweisen kann

Baust du das gut auf → verhält sich das Modell konsistent.

Baust du es schlecht auf → unvorhersehbarer Müll.

Das Modell ist in beiden Fällen dasselbe.

Der Kontext ist das, was einen großartigen Agenten von einem kaputten unterscheidet.

5. Aufgabenzerlegung

Die wichtigste Fähigkeit beim Bau von Agenten.

Fang an mit: wie würde ein Mensch diese Aufgabe erledigen?

Dann frage für jeden Schritt: Kann ein LLM das tun? Ein bisschen Code? Ein API-Aufruf?

Wenn die Antwort nein ist → teile es kleiner auf, bis sie ja ist.

Beispiel – Aufsatz-Schreib-Agent:

1. Gliederung → LLM generiert Struktur
2. Suchbegriffe → LLM generiert, ruft dann Such-API auf
3. Seiten abrufen → Tool-Aufruf
4. Entwurf schreiben → LLM nutzt abgerufene Quellen
5. Selbstkritik → LLM listet Lücken und Schwächen auf
6. Überarbeiten → LLM schreibt basierend auf Kritik neu

Jeder Schritt ist: → Klein → Überprüfbar → Hat eine klare Eingabe und Ausgabe

Wenn die endgültige Ausgabe schlecht ist, weißt du genau, welchen Schritt du reparieren musst.

Das ist die Superkraft der Zerlegung.

TEIL 2: FORTGESCHRITTEN Multi-Agenten-Systeme bauen, die wirklich funktionieren

6. Evaluation (Die langweilige Sache, die Profis von Hobbyisten trennt)

Niemand will über Evals reden.

Jeder, der echte Systeme ausliefert, tut es.

Wie misst du, ob dein Agent funktioniert?

Einfache Aufgaben → korrekte Antworten zählen. Hat der Kundenservice-Bot die Bestandsfrage richtig beantwortet? Ja/nein.

Komplexe Aufgaben → ein LLM als Richter verwenden. Ein zweites Modell bewertet die Ausgabe mit 1–5 anhand einer festen Bewertungsmatrix. Hatte der Aufsatz starke Argumente? Korrekte Zitate? Richtigen Ton?

Zwei Ebenen der Evaluation, die du brauchst:

→ Komponentenebene – funktioniert jeder einzelne Schritt? (Sind die Suchanfragen spezifisch genug? Gibt die Kritik echtes Feedback?)

→ End-to-End – ist die endgültige Ausgabe gut? (Ist der Aufsatz tatsächlich gut?)

Wenn End-to-End fehlschlägt, aber Komponentenevals bestehen → Übergabeproblem. Wenn eine bestimmte Komponente fehlschlägt → muss dieser Agent bearbeitet werden.

Fang von Tag eins an zu evaluieren. Warte nicht auf ein "perfektes" Eval-System. Liefer etwas Schnelles aus und iteriere.

7. Gedächtnis und Wissen

Zwei sehr unterschiedliche Dinge, die Leute verwechseln.

Gedächtnis = dynamisch. Aktualisiert sich bei jedem Durchlauf.

→ Kurzzeitgedächtnis: Der Agent schreibt Notizen, während er arbeitet. Andere Agenten können diese Notizen lesen. → Langzeitgedächtnis: Nach einer Aufgabe reflektiert der Agent. Was lief gut? Was nicht? Speichert Lektionen.

Nächster Durchlauf → lädt diese Lektionen → wendet sie an.

So "trainierst" du Agenten ohne Feintuning. Gib Feedback → Agent verbessert sich mit jedem Durchlauf.

Wissen = statisch. Wird vorab geladen.

→ PDFs, CSVs, interne Dokumente, Datenbankzugriff → Die Referenzbibliothek des Agenten → Einmal geben. Es zieht daraus, wann immer es für genaue Antworten benötigt wird.

Denk so daran:

Gedächtnis = das, was du aus Erfahrung gelernt hast. Wissen = die Lehrbücher, die du nachschlagen kannst.

Beides ist wichtig. Keines ersetzt das andere.

8. Leitplanken

Ein funktionierender Agent ist kein sicherer Agent.

LLMs sind nicht deterministisch.

Sie können das falsche Format haben, eine falsche Tatsache behaupten, von der Aufgabe abweichen.

Leitplanken sind die Qualitätsschranke zwischen "Agent sagt, es ist fertig" und "Aufgabe ist tatsächlich abgeschlossen."

Drei Typen:

Typ 1 – Code-Prüfungen (schnell + günstig)Für deterministische Dinge verwenden. → Ist die Ausgabe das richtige Format? Richtige Länge? Erforderliche Felder vorhanden? Schreibe eine einfache Validierungsfunktion. Führe sie sofort aus. Bevorzuge dies immer, wenn möglich.

Typ 2 – LLM-RichterFür nuancierte Qualitätsprüfungen verwenden. → "Ist diese Antwort sachlich konsistent mit den Quelldokumenten?" → "Ist der Ton professionell und positiv?" Wenn der Richter nein sagt → erklärt warum → Agent überarbeitet → versucht es erneut.

Typ 3 – Mensch im LoopFür Entscheidungen mit hohem Risiko verwenden. Agent stoppt vor der Fertigstellung. Sendet Ausgabe zur menschlichen Überprüfung. Mensch genehmigt, lehnt ab oder fordert Änderungen an.

Die meisten Produktionssysteme verwenden mindestens zwei dieser drei.

1. Die 4 Designmuster, die jeden Agenten verbessern

Diese vier Muster machen Agenten zuverlässig besser.

Muster 1: Reflexion

Hör nicht beim ersten Entwurf auf.

Modell produziert Ausgabe → kritisiert sie → schreibt basierend auf Kritik neu.

E-Mail v1: "Hey, lass uns nächsten Monat treffen. Danke." Kritik: vages Datum, keine Grußformel, Ton zu lässig. E-Mail v2: "Hallo Alex, lass uns vom 5.–7. Januar treffen. Sag Bescheid, was passt. Viele Grüße, Sai."

Wird mit Code noch leistungsstärker – schreiben, ausführen, Fehler erfassen, zurückmelden, Modell korrigiert.

Verwenden für: strukturierte Ausgaben, längeres Schreiben, Code, Verfahrensschritte.

Muster 2: Tool-Nutzung

Gib dem LLM ein Menü von Funktionen, die es aufrufen kann.

Das Modell entscheidet, wann und welches Tool es verwendet.

Websuche. Datenbankabfrage. Codeausführung. Kalender. E-Mail. API-Aufrufe.

LLMs können nichts davon alleine. Tools sind, wie Agenten mit der Welt interagieren.

Muster 3: Planung

Anstatt einer festen Pipeline, lass den Agenten die Schritte entscheiden.

Gib ihm ein Toolkit. Fordere ihn auf, einen Plan zu machen. Führe Schritt für Schritt aus.

Einzelhandelsbeispiel: "Irgendwelche runden Sonnenbrillen unter 100€?" Agent plant: Beschreibungen durchsuchen → Bestand prüfen → nach Preis filtern → antworten.

Du hast diese genauen Schritte nicht skriptgesteuert. Der Agent hat sie gewählt.

Muster 4: Multi-Agenten-Zusammenarbeit

Teile komplexe Arbeit auf spezialisierte Agenten auf.

Rechercheur → Designer → Schreiber.

Jeder Agent ist großartig in seiner spezifischen Aufgabe. Die Ausgabe ist besser, weil kein einzelner Agent versucht, alles zu machen.

10. Multi-Agenten-System-Design

Wie strukturierst du tatsächlich ein Multi-Agenten-System?

Vier Koordinationsmuster, vom einfachsten zum komplexesten.

Muster 1: SequentiellJeder Agent wird fertig → übergibt Ausgabe an nächsten Agenten. Wie ein Fließband. Rechercheur → Designer → Schreiber → Fertig. Leicht zu debuggen. Vorhersagbar. Starte hier.

Muster 2: ParallelFühre unabhängige Agenten gleichzeitig aus. Rechercheur + Designer arbeiten zur gleichen Zeit. Schreiber kombiniert ihre Ausgaben. Schneller. Mehr Koordinationskomplexität.

Muster 3: Manager-HierarchieEin Manager-Agent koordiniert Spezialisten. Manager plant, delegiert, überprüft. Spezialisten berichten an Manager zurück, nicht aneinander. Das häufigste Muster in echten Produktionssystemen heute.

Muster 4: Jeder-mit-JedemJeder Agent kann jeden anderen Agenten benachrichtigen. Chaotisch. Schwer vorhersagbar. Nur für kreative/niedrigriskante Arbeiten, bei denen Variation in Ordnung ist. Nicht in der Produktion verwenden.

Faustregel: Starte sequentiell. Füge Komplexität nur hinzu, wenn du sie brauchst.

TEIL 3: PRODUKTION Was dich wirklich vom Prototyp zum ausgelieferten Produkt bringt

11. Fortgeschrittene Aufgabenzerlegung

In komplexen Multi-Agenten-Systemen kommt es sehr darauf an, wie du zerlegst.

4 Muster:

Funktional – nach technischem Bereich aufteilen. Frontend-Agent. Backend-Agent. Datenbank-Agent. Klassisch für Entwicklungsteams.

Räumlich – nach Datei- oder Verzeichnisstruktur aufteilen. Agent 1 kümmert sich um /services/users/. Agent 2 kümmert sich um /services/orders/. Großartig für große Codebasen. Minimiert Konflikte.

Zeitlich – nach sequentiellen Phasen aufteilen. Phase 1: Recherche. Phase 2: Planung. Phase 3: Bau. Phase 4: Start. Jede Phase ist abgeschlossen, bevor die nächste beginnt.

Datengetrieben – nach Datenpartitionen aufteilen. Agent 1 verarbeitet Woche-1-Protokolle. Agent 2 verarbeitet Woche-2. Usw. Leistungsstark für große Datensätze. Parallelisiere Analysen.

Du kannst diese mischen.

Funktionale Zerlegung für die Hauptstruktur + zeitliche Zerlegung innerhalb jedes Agenten.

Verwende, was immer zu den natürlichen Grenzen deiner Aufgabe passt.

12. Qualitätsverbesserung in der Produktion

System funktioniert, ist aber nicht gut genug.

Zwei Arten von Komponenten. Zwei verschiedene Reparaturstrategien.

Nicht-LLM-Komponenten (Websuche, RAG, OCR, Codeausführung):

→ An den Stellschrauben drehen: Suchzeiträume, Top-k-Ergebnisse, Chunk-Größe, Ähnlichkeitsschwellenwerte → Anbieter wechseln: verschiedene Such-APIs, Vision-Modelle, Parser ausprobieren

LLM-Komponenten (Generierung, Denken, Extraktion):

→ Besser prompten: Einschränkungen, Beispiele, Ausgabeschemata hinzufügen → Ein anderes Modell ausprobieren: einige Modelle sind besser bei Code, andere beim Befolgen von Anweisungen → Schwierigere Aufgaben in kleinere Stücke zerlegen → Feintuning (nur letzter Ausweg – teuer, für die letzten paar % aufheben)

Die Reihenfolge ist wichtig.

Repariere zuerst Prompts. Probiere ein anderes Modell aus. Zerlege weiter. Feintuning zuletzt.

Die meisten Teams erreichen bei Schritt 2 eine ausreichende Qualität.

13. Latenz und Kosten

Qualität zuerst. Dann Geschwindigkeit und Kosten.

Latenz reduzieren:

1. Jeden Schritt messen. Den echten Engpass finden.
2. Alles parallelisieren, was nicht von einem anderen Schritt abhängt.
3. Modelle richtig dimensionieren – schnelles günstiges LLM für einfache Schritte, großes Modell für Denkaufgaben.
4. Schnellere Anbieter ausprobieren – Token-Streaming-Geschwindigkeiten variieren stark.
5. Kontext kürzen – kürzere Prompts decodieren schneller.

Kosten reduzieren:

Echte Kostenaufschlüsselung für einen typischen Recherche-Agenten-Durchlauf:

→ LLM-Generierungsaufrufe: ~$0,04 → Websuch-API-Aufrufe: ~$0,02 → Embedding-Aufrufe: ~$0,005 → Infrastruktur: ~$0,015 → Gesamt pro Durchlauf: ~$0,08

Bei 1.000 Durchläufen/Tag = $80/Tag = $2.400/Monat.

Wie man sie senkt:

→ Zuerst die größten Brocken angehen → Modelle abstufen – günstig für einfache, teuer für schwierige → Ergebnisse aggressiv cachen (Suchergebnisse, Embeddings, Zusammenfassungen) → Ausgaben beschränken ("JSON zurückgeben. Maximal 5 Felder.") → Batch-Operationen wo möglich

14. Beobachtbarkeit: Deine Agenten im Maßstab überwachen

Traditionelle Software: Verfolge den Ausführungspfad. A ruft B auf. B ruft DB auf. Gibt Ergebnis zurück.

KI-Agenten funktionieren nicht so.

Sie sind nicht deterministisch. Gleiche Eingabe → unterschiedliche Ausgabe. Verteilte Ausführung. Externe Abhängigkeiten, die ausfallen können.

Du brauchst zwei Arten von Sichtbarkeit:

Zoom-In-Metriken (Einzeldurchlauf-Debugging)→ Vollständige Ablaufverfolgung: jeder Prompt, jeder Tool-Aufruf, jeder verwendete Token → Warum hat der Agent dieses Tool gewählt? → Was hat jeder Schritt zurückgegeben? → Wo genau ist er fehlgeschlagen?

Protokolliere nicht nur, was passiert ist, sondern warum: "Agent hat Websuche statt RAG gewählt, weil die Abfrage 'aktuell' enthielt" "Reflexion hat 3 Probleme identifiziert: fehlendes Zitat, vages Datum, falscher Ton"

Zoom-Out-Metriken (Systemzustand über viele Durchläufe hinweg)→ Qualitätsbewertungen im Zeitverlauf → Halluzinationsraten → Erfolgsraten → Helfen oder schaden Änderungen?

Du kannst nicht jeden Trace manuell im Maßstab überprüfen.

Verwende Qualitätsstichproben – bewerte einen Prozentsatz aller Durchläufe. Baue einen Trend auf.

So fängst du Regressionen, bevor Benutzer sie bemerken.

15. Sicherheit: Der Teil, über den niemand spricht (aber sollte)

Sicherheit für KI-Agenten ist nicht wie traditionelle App-Sicherheit.

Du schützt dich nicht nur vor externen Angreifern.

Du schützt dich vor deinem EIGENEN System, das gefährliche Entscheidungen trifft.

Die Bedrohungen:

→ Prompt-Injection – bösartiger Inhalt in Benutzereingaben entführt die Anweisungen des Agenten → Unsichere Codegenerierung – Agent schreibt Code, der auf sensible Daten zugreift oder schädliche Dinge tut → Datenleck – PII oder proprietäre Informationen durch Ausgaben oder Tool-Aufrufe offengelegt → Ressourcenerschöpfung – Agenten, die Endlosschleifen drehen oder teure API-Aufrufe verbrennen

Codeausführung ist die riskanteste Funktion.

Wenn du sie aktivierst, so machst du es sicher:

→ In Docker sandboxen. Container wird nach jedem Durchlauf zerstört. → Harte Ressourcenbeschränkungen setzen: Timeouts, Speicherbegrenzungen, CPU-Limits → Nur bestimmte sichere Bibliotheken auf die Whitelist setzen → Alle Eingaben validieren, bevor sie den Agenten erreichen → Alle Ausgaben auf sensible Daten scannen (API-Schlüssel, PII) → Deterministische E/A verwenden – Code gibt strukturiertes JSON zurück, keinen Freitext an Benutzer

Die meisten Teams lernen diese Lektionen auf die harte Tour.

Lies das, bevor du auslieferst.

Das ist der vollständige Kurs.

ZUSAMMENFASSUNG

EINSTEIGER:→ Agenten arbeiten iterativ – planen, handeln, beobachten, wiederholen → Am besten für komplexe mehrschrittige Aufgaben, die ~90% Genauigkeit vertragen → Starte halbautonom, nicht vollständig autonom → Context Engineering ist die eigentliche Intelligenz → Aufgabenzerlegung ist die wichtigste Fähigkeit

FORTGESCHRITTEN:→ Eval von Tag eins – LLM-als-Richter für komplexe Aufgaben → Gedächtnis (dynamisch) ≠ Wissen (statisch) → Drei Arten von Leitplanken: Code → LLM-Richter → Mensch → 4 Muster, die immer helfen: Reflexion, Tool-Nutzung, Planung, Multi-Agenten → Starte sequentiell. Füge Koordinationskomplexität nur bei Bedarf hinzu.

PRODUKTION:→ 4 Zerlegungsmuster: funktional, räumlich, zeitlich, datengetrieben → Repariere Prompts vor dem Feintuning → Miss Latenz und Kosten pro Schritt, dann gehe die größten Brocken an → Zwei Beobachtbarkeitsmodi: Zoom-In-Traces + Zoom-Out-Zustandsmetriken → Sicherheit = Schutz vor dem eigenen System, nicht nur vor Angreifern

Die meisten Leute fangen an, Agenten zu bauen.

Wenige Leute liefern Agenten aus, die zuverlässig im Maßstab funktionieren.

Die Lücke ist alles in diesem Artikel.

Wenn das nützlich war:

→ Reposte, um es zu teilen → Folge @sairahul1 für weitere Aufschlüsselungen wie diese → Lesezeichen setzen – du wirst es beim Bauen nachschlagen

Ich schreibe über KI-Systeme, Produktentwicklung und Automatisierung, die funktioniert, während du schläfst.