Wie man selbstoptimierende KI-Agenten mit Loop Engineering entwickelt

Die meisten KI-Agenten scheitern nicht, weil das Modell schwach ist.

Sie scheitern, weil das System um das Modell herum schwach ist.

Ein Prompt ist vage.

Ein Tool-Aufruf bricht ab.

Der Agent wiederholt den falschen Versuch.

Er vergisst, was er vor zwei Schritten gelernt hat.

Er wiederholt dieselbe schlechte Aktion.

Er erklärt den Erfolg zu früh.

Und niemand hat die Rückkopplungsschleife gebaut, die den Fehler aufgedeckt hätte.

Das ist das eigentliche Problem.

Wenn du KI-Agenten bauen willst, die sich tatsächlich mit der Zeit verbessern, brauchst du mehr als bessere Prompts, mehr Tools oder mehr Autonomie.

Du brauchst Loop Engineering.

Loop Engineering ist die Disziplin, die entwirft, wie ein Agent:

• beobachtet, was passiert ist
• bewertet, ob es funktioniert hat
• seinen nächsten Schritt aktualisiert
• nützliches Feedback speichert
• intelligent wiederholt oder eskaliert
• besser wird, anstatt nur geschäftiger zu werden

Diese Verschiebung ist entscheidend.

Denn die nächste Generation nützlicher KI-Agenten wird nicht dadurch definiert, wie beeindruckend sie in einem einzigen Demo-Durchlauf aussehen.

Sie wird dadurch definiert, ob sie:

• sich von Fehlern erholen können
• aus wiederholten Fehlschlägen lernen
• die Qualität verbessern, ohne dass ein Mensch jeden Schritt beaufsichtigt
• in der Produktion begrenzt, messbar und zuverlässig bleiben

Darüber geht es in diesem Artikel.

Du möchtest mehr praktische KI-Systeme wie dieses? ByteBuilders teilt kurze, nützliche Analysen zu Claude, KI-Workflows, Prompts, Automatisierung und realen technischen Systemen.

Hier abonnieren:

https://bytebuilders.beehiiv.com/subscribe

Wenn du Loop Engineering verstehst, hörst du auf, fragile Agenten zu bauen, die nur funktionieren, wenn alles richtig läuft.

Du beginnst, Systeme zu bauen, die sich verbessern, weil sie dafür entwickelt wurden, zu lernen.

Zunächst: Was „selbstverbessernd“ eigentlich bedeutet

Viele Leute hören „selbstverbessernder Agent“ und stellen sich ein System vor, das sich auf magische Weise selbst neu trainiert oder sich in etwas Autonomes und Geheimnisvolles verwandelt.

Das ist nicht die nützliche Definition.

Ein selbstverbessernder Agent ist normalerweise viel einfacher.

Es ist ein Agent, der Signale aus früheren Versuchen nutzen kann, um beim nächsten Versuch bessere Entscheidungen zu treffen.

Das kann geschehen durch:

• Wiederholungen mit besserem Kontext
• bewertungsbasierte Überarbeitung
• Erinnerung an frühere Fehlschläge
• Korrekturen der Tool-Nutzung
• Bewertung der Ausgabe
• menschliche Feedback-Schleifen
• Regelaktualisierungen
• gespeicherte erfolgreiche Muster

Mit anderen Worten:

Selbstverbesserung ist normalerweise keine Modellevolution. Es ist Loop-Evolution.

Das Basismodell kann gleich bleiben.

Was sich verbessert, ist das Verhalten des Systems um das Modell herum.

Das ist ein viel praktischerer und technikfreundlicherer Rahmen.

Warum die meisten Agenten sich nicht von selbst verbessern

Eine überraschende Anzahl von Agenten ist nicht wirklich darauf ausgelegt, sich zu verbessern.

Sie sind darauf ausgelegt, fortzufahren.

Das ist nicht dasselbe.

Viele Agentensysteme funktionieren heute im Grunde so:

1. Aufgabe lesen
2. Denken
3. Tool aufrufen
4. Fortfahren, bis gestoppt

Das Problem ist, dass dieser Struktur oft fehlt:

• explizite Erfolgskriterien
• Fehlerklassifizierung
• zustandsbewusste Wiederholungen
• Erinnerung an das, was bereits fehlgeschlagen ist
• Vergleich zwischen Versuchen
• Ausgabebewertung
• Eskalationsregeln

Der Agent verbessert sich also nicht.

Er schleift nur.

Das ist der Unterschied zwischen roher Iteration und intelligenter Iteration.

Loop Engineering ist das, was diesen Unterschied schafft.

Loop Engineering ist die eigentliche Architekturebene

Der einfachste Weg, Loop Engineering zu verstehen, ist dieser:

Das Prompting sagt dem Modell, was es tun soll.

Loop Engineering sagt dem System, wie es sich verhalten soll, nachdem es es versucht hat.

Das beinhaltet Fragen wie:

• Was soll der Agent nach einem fehlgeschlagenen Tool-Aufruf tun?
• Wann soll er wiederholen versus die Strategie wechseln?
• Wie viele Versuche sind erlaubt?
• Was soll im Speicher abgelegt werden?
• Was soll automatisch bewertet werden?
• Wann soll ein Mensch übernehmen?
• Was zählt als Verbesserung?

Deshalb gehört Loop Engineering in die Architekturdiskussion, nicht nur in die Prompt-Diskussion.

Die Kernschleife hinter selbstverbessernden Agenten

Die meisten nützlichen selbstverbessernden Agenten folgen einer wiederholten Struktur, die ungefähr so aussieht:

1Ziel
2  ↓
3Planen
4  ↓
5Handeln
6  ↓
7Ergebnis beobachten
8  ↓
9Qualität bewerten
10  ↓
11Signal speichern
12  ↓
13Wiederholen / Überarbeiten / Eskalieren / Abschließen

Das ist die Grundlage.

Das System verbessert sich, wenn jeder Durchlauf durch die Schleife die nächste Entscheidung auf nützliche Weise verändert.

Nicht jeder Agent braucht eine komplexe Version.

Aber jeder zuverlässige Agent braucht eine Version davon.

Der Unterschied zwischen einem naiven Agenten und einem loop-engineered Agenten

Dimension

Naiver Agent

Loop-Engineered Agent

Aufgabenbearbeitung

versucht Aufgabe einmal oder setzt blind fort

arbeitet in begrenzten Zyklen

Fehlerreaktion

wiederholt zufällig oder bricht hart ab

wiederholt basierend auf klassifiziertem Fehler

Speicher

wenig oder kein nützlicher Zustand

speichert umsetzbaren Kontext

Bewertung

geht davon aus, dass Fertigstellung Erfolg bedeutet

prüft Ausgaben anhand von Kriterien

Verbesserung

zufällig

entworfen

Menschliche Rolle

nur Notfall-Ausweichlösung

bewusster Eskalationspunkt

Zuverlässigkeit

inkonsistent

wird mit der Zeit progressiv stärker

Das ist die Verschiebung.

Der loop-engineered Agent ist auf Modellebene nicht unbedingt „schlauer“.

Er operiert nur innerhalb eines besseren Systems.

Die fünf Bausteine selbstverbessernder Agenten

Wenn du möchtest, dass sich ein Agent verbessert, brauchst du eine Schleife mit Struktur.

Diese fünf Bausteine sind am wichtigsten.

1. Klare Erfolgskriterien

Wenn das System nicht weiß, wie „gut“ aussieht, kann es sich nicht dahingehend verbessern.

Erfolgskriterien können sein:

• exaktes Ausgabeformat
• Korrektheitsschwelle
• Anforderung einer fundierten Antwort
• Tool-Abschlusssignal
• bestandenes Testergebnis
• menschliche Genehmigung
• aufgabenspezifische Punktzahl

Ohne dies hat der Agent nichts Stabiles, um das herum er optimieren kann.

1. Bewertungsebene

Die Bewertungsebene sagt dem Agenten, ob sein Versuch funktioniert hat.

Dies kann sein:

• regelbasierte Prüfungen
• Schema-Validierung
• Unit-Tests
• LLM-als-Richter-Bewertung
• Retrieval-Grundlagenprüfungen
• Geschäftslogik-Validierung
• menschliche Überprüfung

Dies ist der Unterschied zwischen „es hat eine Antwort produziert“ und „es hat eine nützliche Antwort produziert“.

1. Feedback-Speicher

Selbstverbesserung erfordert Speicher, aber nicht nur rohe Historie.

Der Agent braucht nutzbaren Speicher.

Guter Feedback-Speicher beinhaltet Dinge wie:

• letzter Fehlergrund
• vorheriger Tool-Fehler
• bekanntermaßen bester erfolgreicher Pfad
• bekannte schlechte Strategie, die es zu vermeiden gilt
• Benutzerpräferenz oder -korrektur
• komprimierte Zusammenfassung vorheriger Versuche

Nicht der gesamte Kontext sollte bestehen bleiben.

Nur der Kontext, der der nächsten Entscheidung hilft.

1. Strategieüberarbeitung

Nach der Bewertung muss der Agent entscheiden, was sich ändert.

Das kann beinhalten:

• ein neues Tool ausprobieren
• die Aufgabe eingrenzen
• eine klärende Frage stellen
• mehr Informationen abrufen
• von Aktion zu Erklärung wechseln
• an einen Menschen eskalieren

Hier wird das System tatsächlich anpassungsfähig.

1. Grenzen und Stoppbedingungen

Ein selbstverbessernder Agent braucht dennoch Kontrolle.

Sonst bekommst du keine Verbesserung.

Du bekommst Chaos.

Setze Grenzen für:

• Wiederholungen
• Kosten
• Latenz
• destruktive Aktionen
• Schwellenwerte für menschliche Genehmigung
• Aufgabenabbruchregeln

Eine begrenzte Schleife ist wertvoller als eine uneingeschränkte.

Wie Loop Engineering in der Praxis aussieht

Hier ist ein einfaches Muster, das für viele Agenten gut funktioniert.

Schleife 1: Versuch

Der Agent versucht die Aufgabe mit dem aktuellen Kontext.

Schleife 2: Bewerten

Eine Prüfung läuft.

Beispiele:

• hat das Schema validiert?
• hat der Code die Tests bestanden?
• hat die Antwort die erforderliche Quelle zitiert?
• hat das Tool die richtigen Felder zurückgegeben?

Schleife 3: Diagnose

Wenn es fehlgeschlagen ist, klassifiziere warum.

Beispiele:

• fehlender Kontext
• schlechte Tool-Argumente
• Retrieval-Fehler
• halluzinierte Annahme
• unvollständige Ausgabe
• Richtlinienkonflikt

Schleife 4: Anpassen

Ändere den nächsten Versuch.

Beispiele:

• mehr Kontext abrufen
• die Aufgabe enger umformulieren
• ein anderes Tool ausprobieren
• Validierungsregeln hinzufügen
• Benutzer nach fehlenden Details fragen

Schleife 5: Nützliches Signal speichern

Speichere nur das, was zukünftigen Durchläufen hilft.

Dann wiederholen.

Das ist Loop Engineering in operativen Begriffen.

Ein praktisches Diagramm für loop-engineered Agenten

1Benutzerziel
2   ↓
3Aufgabeninterpreter
4   ↓
5Planer
6   ↓
7Tool / Aktionsschicht
8   ↓
9Ergebnis
10   ↓
11Bewerter
12   ├── bestanden → abschließen
13   ├── fehlgeschlagen: Kontext fehlt → mehr abrufen
14   ├── fehlgeschlagen: schlechte Tool-Nutzung → Aktion überarbeiten
15   ├── fehlgeschlagen: geringes Vertrauen → eskalieren
16   └── fehlgeschlagen: behebbar → mit Speicher wiederholen

Hier wird die Agentenqualität systematisch statt zufällig.

Woher Selbstverbesserungssignale kommen sollten

Dies ist eine der wichtigsten Designfragen.

Wenn du die falschen Signale in die Schleife einspeist, könnte der Agent in die falsche Richtung optimieren.

Starke Quellen für Verbesserungssignale sind:

Deterministische Signale

• Tests bestanden oder nicht bestanden
• Schema validiert oder nicht
• API-Status ist Erfolg oder Fehler
• Ausgabe enthält erforderliche Felder oder nicht
• Richtlinienregel ist erfüllt oder verletzt

Workflow-Signale

• Anzahl der Wiederholungen
• Tool-Latenz
• Schritt, in dem der Fehler aufgetreten ist
• Vertrauensschwelle überschritten
• Eskalationshäufigkeit

Menschliche Signale

• Daumen hoch / Daumen runter
• korrigierte Ausgabe
• akzeptierter versus abgelehnter Entwurf
• manuelle Überschreibungsmuster
• Prüfernotizen

Vergleichssignale

• Ausgabequalität Version A versus Version B
• Vergleich der Retrieval-Varianten
• Vergleich der Tool-Pfade
• Punktzahlverbesserung über wiederholte Durchläufe hinweg

Die besten selbstverbessernden Agenten kombinieren normalerweise mindestens zwei dieser Kategorien.

Die besten Schleifen verbessern den Workflow, nicht nur die Antwort

Hier wird das Design ausgereifter.

Eine schwache Implementierung verwendet Schleifen nur, um Text neu zu generieren.

Eine stärkere Implementierung verwendet Schleifen, um den gesamten Workflow zu verbessern.

Das bedeutet, dass der Agent sich verbessern kann, indem er ändert:

• was er abruft
• welche Tools er verwendet
• die Reihenfolge der Schritte
• woran er sich erinnert
• was er ignoriert
• ob er früher um Klärung bittet
• ob er früher aufhört

Das ist viel leistungsfähiger als „die Antwort noch einmal umschreiben“.

Das System wird auf Prozessebene selbstkorrigierend.

Prompt-Muster, die Selbstverbesserung unterstützen

Prompting ist immer noch wichtig.

Es muss nur die Schleife unterstützen.

Hier sind nützliche Prompt-Muster.

Prompt 1: Bewertungsbewusster Aktions-Prompt

1Du führst eine Aufgabe innerhalb eines begrenzten Workflows aus.
2Dein Ziel ist es nicht nur, eine Antwort zu produzieren, sondern eine Antwort, die die Bewertung besteht.
3Wenn Informationen fehlen, frage danach oder rufe sie ab.
4Wenn das Ergebnis unsicher ist, schließe es nicht mit Zuversicht ab.
5Wenn ein vorheriger Versuch fehlgeschlagen ist, vermeide es, dieselbe Strategie zu wiederholen, es sei denn, der Kontext hat sich geändert.

Prompt 2: Fehlerdiagnose-Prompt

1Der vorherige Versuch ist fehlgeschlagen.
2Klassifiziere den wahrscheinlichen Fehlergrund in eine dieser Kategorien:
3- fehlender Kontext
4- Tool-Missbrauch
5- schlechte Annahme
6- unvollständige Ausgabe
7- Formatierungs- oder Schemafehler
8- Richtlinienkonflikt
9Schlage dann die kleinste nächste Änderung vor, die die Erfolgswahrscheinlichkeit verbessert.

Prompt 3: Überarbeitungs-Prompt

1Überarbeite den nächsten Versuch unter Verwendung des untenstehenden Bewerter-Feedbacks.
2Wiederhole nicht denselben Argumentationspfad, wenn er bereits fehlgeschlagen ist.
3Bevorzuge eine engere, fundiertere Lösung.
4Rufe bei Bedarf mehr Kontext ab, bevor du antwortest.

Prompt 4: Speicherzusammenfassungs-Prompt

1Fasse den letzten Versuch in einem kurzen Speicherblock für den nächsten Durchlauf zusammen.
2Füge nur hinzu:
3- was fehlgeschlagen ist
4- was funktioniert hat
5- was vermieden werden sollte
6- was als nächstes versucht werden sollte
7Halte es unter 120 Wörtern.

Das sind keine Zauber-Prompts.

Es sind Prompts, die darauf ausgelegt sind, das Schleifenverhalten zu verstärken.

Eine einfache Python-ähnliche Schleifenarchitektur

Unten ist ein vereinfachtes Beispiel dafür, wie Loop Engineering im Code aussehen kann:

1MAX_ATTEMPTS = 4
2
3memory = []
4
5for attempt in range(MAX_ATTEMPTS):
6    context = build_context(task=task, memory=memory)
7    plan = agent.plan(context)
8    result = agent.act(plan)
9
10    evaluation = evaluator.check(task=task, result=result)
11
12    if evaluation.passed:
13        return {
14            "status": "success",
15            "result": result,
16            "attempt": attempt + 1,
17        }
18
19    failure_summary = agent.summarize_failure(
20        result=result,
21        evaluation=evaluation,
22    )
23
24    memory.append({
25        "attempt": attempt + 1,
26        "failure": failure_summary,
27        "suggested_fix": evaluation.next_step,
28    })
29
30    if evaluation.requires_human:
31        return {
32            "status": "escalated",
33            "reason": evaluation.reason,
34            "attempt": attempt + 1,
35            "memory": memory,
36        }
37
38return {
39    "status": "failed",
40    "reason": "max_attempts_reached",
41    "memory": memory,
42}

Dies ist bewusst einfach gehalten.

Der wichtige Punkt ist nicht der Code selbst.

Es ist die Struktur:

• versuchen
• bewerten
• Signal speichern
• anpassen
• wiederholen oder eskalieren

Das ist das Muster, das man verinnerlichen sollte.

Wo Loop Engineering am wichtigsten ist

Dieser Ansatz ist besonders wertvoll in Workflows, bei denen der Erfolg beim ersten Durchlauf nicht garantiert ist.

Coding-Agenten

Perfekt für Schleifen, da das System:

• Tests ausführen
• Fehler untersuchen
• Code überarbeiten
• Ausgaben vergleichen
• nur anhalten kann, wenn die Verifizierung bestanden ist

Support-Agenten

Nützlich, da das System:

• Richtlinienkontext abrufen
• eine Antwort entwerfen
• die Fundierung prüfen
• bei hohem Risiko um Genehmigung bitten kann

Recherche-Agenten

Hilfreich, da das System:

• mehrere Quellen sammeln
• Lücken identifizieren
• erneut suchen
• nur synthetisieren kann, wenn die Beweise ausreichen

Dokumentextraktions-Agenten

Nützlich, da das System:

• Dateien parsen
• Schema validieren
• mehrdeutige Felder wiederholen
• Fälle mit geringem Vertrauen eskalieren kann

Operative Workflow-Agenten

Wertvoll, da das System:

• APIs aufrufen
• Ergebnisse prüfen
• sich von Teilfehlern erholen
• Ausnahmen an Menschen weiterleiten kann

In all diesen Fällen ist die Schleifenqualität wichtiger als die Einmal-Generierungsqualität.

Häufige Fehler im Loop Engineering

Fehler 1: Wiederholungen als Verbesserung behandeln

Mehr Versuche bedeuten nicht automatisch besseres Lernen.

Wenn das System dasselbe Verhalten wiederholt, verbessert es sich nicht.

Es schleift nur.

Fehler 2: Zu viel Speicher speichern

Nicht jeder vergangene Kontext hilft.

Zu viel Speicher kann den nächsten Versuch verunreinigen.

Speichere komprimierte, umsetzbare Lektionen – keine rohen Transkriptionshaufen.

Fehler 3: Bewertung überspringen

Ohne eine Prüfung kann der Agent nicht wissen, ob er besser geworden ist.

Dies ist der häufigste strukturelle Fehler.

Fehler 4: Keine Stoppbedingung

Ein uneingeschränkter Agent ist nicht fortschrittlich.

Er ist teuer.

Fehler 5: Menschliches Feedback ignorieren

Wenn Menschen immer wieder dasselbe korrigieren und die Schleife dieses Signal nie nutzt, verbessert sich das System nicht wirklich.

Fehler 6: Eine einzige riesige Schleife für jede Aufgabe verwenden

Verschiedene Aufgaben brauchen unterschiedliche Schleifen.

Ein Support-Agent und ein Coding-Agent sollten nicht dieselbe Wiederholungslogik oder dieselben Bewertungsregeln teilen.

Die praktische Build-Reihenfolge, die ich empfehle

Wenn du von Grund auf baust, verwende diese Reihenfolge.

Schritt 1: Erfolg klar definieren

Wie sieht ein gutes Ergebnis aus?

Schritt 2: Fehlerkategorien definieren

Warum scheitert dieser Agent normalerweise?

Schritt 3: Zuerst den Bewerter bauen

Wie wird das System wissen, ob es erfolgreich war oder gescheitert ist?

Schritt 4: Speicherregeln entwerfen

Was sollte zwischen den Versuchen bestehen bleiben?

Schritt 5: Wiederholungsstrategie definieren

Was ändert sich zwischen Versuch eins und Versuch zwei?

Schritt 6: Eskalationslogik hinzufügen

Wann sollte ein Mensch eingreifen?

Schritt 7: Alles Wichtige protokollieren

Du kannst nicht verbessern, was du nicht beobachtest.

Schritt 8: Erst optimieren, nachdem die Schleife funktioniert

Mache das System nicht zu kompliziert, bevor der Kernzyklus stabil ist.

Diese Reihenfolge hält Teams fokussiert auf das Verhalten statt auf den Hype.

Eine einfache Checkliste, bevor du einen Agenten „selbstverbessernd“ nennst

Verwende dies als Realitätscheck.

• Weiß der Agent, wie Erfolg aussieht?
• Bewertet er jeden Versuch?
• Speichert er nützliche Lektionen aus Fehlern?
• Ändert er die Strategie basierend auf Feedback?
• Vermeidet er es, blind denselben fehlgeschlagenen Pfad zu wiederholen?
• Weiß er, wann er aufhören muss?
• Weiß er, wann er an einen Menschen eskalieren muss?
• Kannst du messen, ob er tatsächlich besser wird?

Wenn die meisten davon fehlen, ist das System wahrscheinlich nicht selbstverbessernd.

Es ist nur iterativ.

Abschließende Gedanken

Die Zukunft der KI-Agenten sind nicht nur bessere Prompts, mehr Tools oder längere Ketten.

Es sind bessere Schleifen.

Das ist es, was Loop Engineering ermöglicht.

Es verwandelt einen Agenten von einem Einmal-Generator in ein System, das:

• beobachten
• bewerten
• anpassen
• erinnern
• intelligent wiederholen
• sich unter realen Bedingungen verbessern kann

So sieht Selbstverbesserung in der Produktions-KI tatsächlich aus.

Kein Mysterium.

Keine Magie.

Nur besseres Systemdesign.

Wenn du stärkere Agenten willst, frage nicht nur, wie man sie zum Handeln bringt.

Frage, wie man sie aus dem lernen lässt, was als Nächstes passiert ist.

Dort liegt der wirkliche Hebel.