Hallo zusammen, hier ist Alex von agntai.net! Heute möchte ich über etwas sprechen, das mir in letzter Zeit oft durch den Kopf geht: das überraschend knifflige Thema, KI-Agenten dazu zu bringen, tatsächlich Dinge effektiv zu erinnern, besonders über längere Zeiträume oder über verschiedene Aufgaben hinweg. Wir reden hier nicht nur über das Erinnern an ein paar Gesprächswendungen. Ich meine echte, persistente Erinnerungen, die es einem Agenten ermöglichen, zu lernen, sich anzupassen und auf seinen Erfahrungen auf eine sinnvolle Weise aufzubauen, ähnlich wie ein Mensch es tut.
Das klingt einfach, oder? Man speichert einfach ein paar Daten. Aber wie jeder, der versucht hat, mehr als einen grundlegenden Chatbot zu bauen, weiß, wird es schnell kompliziert. Ich habe die meiste Zeit der letzten sechs Monate mit genau diesem Problem gekämpft, bei einem neuen internen Tool, das wir entwickeln – einem autonomen Code-Refactoring-Agenten. Und ich kann euch sagen, die naiven Ansätze zerfallen schneller als ein billiger Regenschirm im Hurrikan.
Wir haben alle die beeindruckenden Demos von Agenten gesehen, die planen, ausführen und sogar sich selbst korrigieren können. Aber oft arbeiten diese Agenten innerhalb eines ziemlich begrenzten, kurzfristigen Kontexts. Sie lösen ein Problem und dann puff, ein großer Teil dieses Wissens ist weg, wenn das nächste Problem auftaucht. Für etwas wie Code-Refactoring, wo das Verständnis früherer Entscheidungen, vorheriger Code-Strukturen und sogar spezifischer Entwickler-Präferenzen entscheidend ist, ist dieses kurzfristige Gedächtnis eine lähmende Einschränkung.
Deshalb möchte ich heute über das sprechen, was ich “Der Persistente Agent: Architektur für Langzeitgedächtnis in autonomen Systemen” nenne. Ich werde einige der Fallstricke teilen, auf die ich gestoßen bin, die Lösungen, die ich erkundet habe, und was ich als die besten Methoden gefunden habe, um Agenten zu bauen, die wirklich lernen und sich erinnern.
Das Problem mit “Nur Eingaben Speichern”
Mein erster Gedanke, und wahrscheinlich der vieler von euch, war, einfach ein laufendes Protokoll von Interaktionen zu führen. Wenn der Agent sich an etwas erinnern muss, füttern wir ihn einfach mit den relevanten Teilen der Gesprächshistorie oder vergangenen Beobachtungen. Das funktioniert okay für ein paar Wendungen, vielleicht sogar für eine kurze Sitzung. Aber versucht das mit einem Agenten, der über Tage oder Wochen an einem Code-Basis arbeiten muss und Hunderte von kleinen Änderungen vornimmt, und ihr stößt schnell auf zwei große Wände:
- Kontextfenster-Überlastung: Große Sprachmodelle (LLMs) haben endliche Kontextfenster. Selbst bei größeren Fenstern, die zunehmend üblich werden, ist es nicht nachhaltig, die gesamte Historie von Entscheidungen, Code-Änderungen und Beobachtungen in jede Eingabe zu quetschen. Es wird unglaublich teuer, langsam und irgendwann geht einfach der Platz aus.
- Informationsüberlastung & “Im Mittendrin Verloren”: Selbst wenn du alles unterbringen könntest, sind LLMs nicht großartig darin, die Nadel im Heuhaufen innerhalb eines massiven Kontexts zu finden. Wichtige Details gehen unter, und die Leistung des Agenten verschlechtert sich. Es ist, als würde man versuchen, sich an ein spezifisches Detail aus einem Buch zu erinnern, das man vor Jahren überflogen hat – man weiß, dass es irgendwo dort ist, aber es effizient zu finden, ist schwierig.
Ich erinnere mich an einen bestimmten Nachmittag, an dem ich mir die Haare raufte, weil unser Refactoring-Agent immer wieder die gleichen grundlegenden Änderungen an der Code-Struktur vorschlug, die er bereits implementiert und eine Stunde zuvor zurückgenommen hatte. Es war wie Groundhog Day für das arme Ding. Die Historie war da, aber sie wurde nicht effektiv genutzt. Das war mein Weckruf, dass ein strukturierterer Ansatz nötig war.
Über die einfache Historie hinaus: Der geschichtete Erinnerungsansatz
Was ich als viel effektiver empfunden habe, ist ein geschichteter Erinnerungsansatz, inspiriert davon, wie Menschen Informationen verarbeiten und speichern. Wir erinnern uns nicht einfach an jedes einzelne Erlebnis in einer flachen Liste. Wir haben verschiedene Arten von Gedächtnis: Kurzzeitgedächtnis, Langzeitgedächtnis, semantisches, episodisches. KI-Agenten können von einer ähnlichen Struktur profitieren.
Kurzzeit-Arbeitsgedächtnis (Der Notizblock)
Dies ist der unmittelbare Kontext. Worauf konzentriert sich der Agent gerade? Was sind die unmittelbaren Eingaben und Ausgaben? Hier leben dein aktueller Prompt, die neuesten Beobachtungen und vorübergehenden Gedanken. Es wird oft vom Kontextfenster des LLM selbst verwaltet, plus vielleicht einem sehr kleinen, schnell zugänglichen Schlüssel-Wert-Speicher für Variablen, die spezifisch für die aktuelle Aufgabenbearbeitung sind.
Für unseren Refactoring-Agenten umfasst dies den spezifischen Codeblock, den er untersucht, das unmittelbare Refactoring-Ziel (z. B. “Funktion `calculate_price` extrahieren”) und alle Zwischenstufen, die er in Betracht zieht.
Episodisches Gedächtnis (Das “Was ist Wann” Protokoll)
Hier zeichnet der Agent Reihenfolgen von Ereignissen, durchgeführten Aktionen, gemachten Beobachtungen und deren Ergebnissen auf. Man kann es als ein detailliertes Tagebuch oder Protokoll der Erfahrungen des Agenten betrachten. Es ist entscheidend für das Verständnis von Ursache und Wirkung und für das Lernen aus Erfolgen und Misserfolgen.
Mein erster Versuch daran bestand darin, einfach JSON-Blobs in eine Dokumentdatenbank zu dumpen. Es war ein Fortschritt gegenüber reinem Text, hatte aber immer noch keine Struktur. Was ich dann getan habe, war, strukturierte Ereignisse zu speichern, oft mit einem Schema, das die Kernkomponenten der Aktionsschleife eines Agenten erfasst:
- Zeitstempel: Wann ist das passiert?
- Agentenzustand: Was hat der Agent “gedacht” oder versucht zu tun? (z. B. aktuelles Ziel, Teilziele)
- Beobachtung: Was hat der Agent wahrgenommen? (z. B. Codeausschnitt, Fehlermeldung, Benutzerfeedback)
- Aktion: Was hat der Agent getan? (z. B. vorgeschlagene Codeänderung, einen Test durchgeführt, um Klarstellung gebeten)
- Ergebnis: Was war das Ergebnis der Aktion? (z. B. Test bestanden, Code eingecheckt, Fehler aufgetreten)
Diese Struktur ermöglicht eine viel einfachere Abfrage und Wiederherstellung später. Für die Speicherung benutze ich derzeit eine Kombination aus PostgreSQL (für Metadaten und strukturierte Abfragen) und eingebetteten Vektoren, die in einer Vektordatenbank wie Qdrant oder Pinecone für die semantische Suche gespeichert sind.
# Beispiel für einen vereinfachten episodischen Gedächtniseintrag (Python dict zur Veranschaulichung)
episode_entry = {
"timestamp": "2026-03-29T10:30:00Z",
"agent_goal": "Refactor `legacy_billing_logic` um `PriceCalculator` zu nutzen",
"sub_task": "Extrahiere `calculate_total` in eigene Methode",
"observation": {
"type": "code_snippet",
"content": "def legacy_billing_logic(items, discounts):\n # ... alte komplexe Logik ...\n total = sum(item.price for item in items)\n # ... Rabattanwendung ...\n return total"
},
"action": {
"type": "propose_code_change",
"details": "Vorgeschlagen, `sum(item.price for item in items)` in `_calculate_subtotal` zu extrahieren."
},
"outcome": {
"type": "linter_warning",
"message": "Funktionsname `_calculate_subtotal` ist zu allgemein. Erwägen Sie `_calculate_items_subtotal`."
},
"embedding": [0.1, 0.2, ..., 0.9] # Vektorielle Darstellung des Eintrags
}
# Dieses dict würde dann oft mit seinem embedding in einer DB gespeichert.
Semantisches Gedächtnis (Die Wissensbasis)
Hier residieren verallgemeinerte Kenntnisse und destillierte Einsichten. Anstatt sich an jede einzelne Instanz eines Ereignisses zu erinnern, speichert das semantische Gedächtnis die Muster, Regeln und Konzepte, die aus diesen Ereignissen abgeleitet sind. Für unseren Refactoring-Agenten könnte dies Folgendes beinhalten:
- Gemeinsame Refactoring-Muster (z. B. “Methode extrahieren,” “Parameterobjekt einführen”).
- Best Practices für die spezifische Sprache/Framework (z. B. “Python-Dekoratoren sollten für Querfachthemen verwendet werden”).
- Spezifische Projektkonventionen (z. B. “alle Dienstprogrammfunktionen gehen in `utils.py`”).
- Entwicklerpräferenzen (z. B. “Alex bevorzugt explizite Typanmerkungen”).
Das semantische Gedächtnis wird oft durch die Verarbeitung des episodischen Gedächtnisses aufgebaut. Wenn der Agent wiederholt auf ein ähnliches Problem trifft und erfolgreich eine Lösung anwendet, kann diese Lösung in eine verallgemeinerte Regel oder Richtlinie destilliert werden. Hier glänzt die retrieval-augmented generation (RAG) wirklich. Du fütterst den Agenten nicht mit rohen Erfahrungen; du fütterst ihn mit relevantem, destilliertem Wissen.
Ich habe mit ein paar Methoden experimentiert, um dies aufzubauen:
- Manuelle Kuratierung: Zunächst habe ich einige gängige Refactoring-Muster und Projektregeln manuell bereitgestellt. Das funktioniert für den Start, ist aber nicht skalierbar.
- Automatisierte Extraktion (LLM-basiert): Periodisch lasse ich ein LLM über eine Charge aktueller episodischer Erinnerungen laufen, und fordere es auf, “allgemeine Regeln, Best Practices oder häufige Fallen zu extrahieren, die in diesen Interaktionen beobachtet wurden.” Die Ausgabe wird dann als prägnante, abfragbare Fakten oder Richtlinien gespeichert.
- Einbettungen von Konzepten: Ähnlich wie beim episodischen Gedächtnis, aber auf abstrakte Konzepte fokussiert. Beispielsweise würde ein Dokument, das “SOLID Prinzipien” beschreibt, eingebettet und gespeichert, bereit zur Abfrage, wenn ein Agent eine Designentscheidung überlegt.
Der Schlüssel dabei ist, dass das semantische Gedächtnis nicht einfach ein Dump ist; es wird aktiv kuratiert und organisiert, um eine effiziente Abfrage zu ermöglichen. Beispielsweise könnte der Agent, wenn er über ein Refactoring nachdenkt, sein semantisches Gedächtnis nach “Best Practices für große Klassen-Refactorings” oder “häufigen Fallen beim Einführen neuer Schnittstellen” abfragen.
Reflexives Gedächtnis (Die Selbstbewertungs-Ebene)
Dies ist vielleicht die fortschrittlichste und oft übersehene Ebene. Reflexives Gedächtnis bezieht sich auf die Fähigkeit des Agenten zur Introspektion, seine eigene Leistung zu bewerten und seine internen Modelle oder Strategien zu aktualisieren. Es ist der Teil des “Lernens aus Fehlern”.
Nach einer Abfolge von Aktionen, insbesondere wenn ein Fehler aufgetreten ist oder ein besonders erfolgreiches Ergebnis erzielt wurde, kann der Agent dazu angeregt werden, zu reflektieren:
- “Was lief bei diesem Refactoring gut?”
- “Welche Herausforderungen hatte ich, und wie hätte ich sie besser angehen können?”
- “Gibt es Muster in meinen Misserfolgen?”
- “Wie kann ich meine Planung für ähnliche Aufgaben in der Zukunft verbessern?”
Die Ergebnisse dieser Reflexionsfragen können dann verwendet werden, um das semantische Gedächtnis zu aktualisieren (z.B. “eine neue Best Practice für den Umgang mit X hinzufügen”) oder sogar die Kernaufforderungen oder Entscheidungsheuristiken des Agenten zu modifizieren. Hier findet die echte Anpassung statt.
Für unseren Agenten, nach einem gescheiterten Versuch, eine komplexe Funktion zu refaktorisieren, habe ich eine Reflexionsschleife eingerichtet. Der Agent würde das episodische Gedächtnis dieses Versuchs überprüfen, herausfinden, wo es schiefgelaufen ist (z.B. “fehlte die Berücksichtigung von Nebeneffekten durch Parameteränderungen”), und dann eine neue Richtlinie generieren: “Bei der Modifizierung von Funktionssignaturen immer alle Aufrufstellen auf potenzielle Nebeneffekte überprüfen und entsprechend aktualisieren.” Diese Richtlinie wird dann zu seinem semantischen Gedächtnis hinzugefügt und verbessert zukünftige Entscheidungen.
# Vereinfachter Python-Pseudocode für eine Reflexionsschleife
def reflect_on_task(agent_id, task_id, episodic_memories):
llm_prompt = f"""
Du bist ein KI-Assistent, der über eine vergangene Aufgabe reflektiert.
Überprüfe die folgende Ereignisfolge und Beobachtungen für die Aufgabe {task_id}:
{format_episodic_memories_for_llm(episodic_memories)}
Basierend darauf beantworte Folgendes:
1. Was war das Hauptziel dieser Aufgabe?
2. War die Aufgabe erfolgreich oder nicht? Warum?
3. Welche spezifischen Maßnahmen oder Entscheidungen führten zu diesem Ergebnis?
4. Welche allgemeinen Lektionen, Best Practices oder Fallstricke können aus dieser Erfahrung abgeleitet werden?
5. Wie könnte der Ansatz für zukünftige, ähnliche Aufgaben verbessert werden?
"""
reflection_output = call_llm(llm_prompt)
# Analysiere reflection_output und aktualisiere das semantische Gedächtnis
# z.B. neue Best Practices extrahieren und speichern.
store_new_semantic_knowledge(agent_id, reflection_output["lessons"])
Alles Zusammenfügen: Die Abruffunktion
All diese Gedächtnisschichten zu haben, ist großartig, aber der Agent muss wissen wann und wie man sie nutzt. Hier kommt die Abruffunktion ins Spiel. Immer wenn der Agent an einem Entscheidungspunkt ist, bevor er seine nächste Handlung generiert, fragt er seine verschiedenen Gedächtnisspeicher ab.
Die Abfrage selbst wird oft vom LLM basierend auf dem aktuellen kurzfristigen Kontext und Ziel generiert. Wenn das aktuelle Ziel des Agenten zum Beispiel “die beste Refactoring-Strategie für die `ShoppingCart`-Klasse entscheiden” ist, könnte er Abfragen wie folgt generieren:
- “Jüngste Refactoring-Versuche an `ShoppingCart`” (Episodisches Gedächtnis)
- “Best Practices für das Refactoring großer Klassen” (Semantisches Gedächtnis)
- “Entwicklerpräferenzen für Klassenstruktur” (Semantisches Gedächtnis, möglicherweise abgeleitet aus vergangenen Reflexionen oder manuellen Eingaben)
- “Vergangene Misserfolge im Zusammenhang mit Änderungen der Klassenhierarchie” (Reflektierendes/Episodisches Gedächtnis)
Die abgerufenen Informationen, oft eine kurze Zusammenfassung oder einige relevante Schnipsel, werden dann in das Kontextfenster des LLM für den aktuellen Entscheidungsfindungsprozess eingefügt. Dies ermöglicht dem LLM, informierte Entscheidungen zu treffen, ohne jedes Mal die gesamte Historie verarbeiten zu müssen.
Dieser Prozess des dynamischen Abrufs relevanter Informationen und deren Einspeisung in die Aufforderung ist es, was das langfristige Gedächtnis für Agenten wirklich freisetzt. Er hält das Kontextfenster handhabbar und sorgt dafür, dass der Agent von seinen gesammelten Erfahrungen profitiert.
Handlungsrelevante Erkenntnisse für Ihre eigenen Agenten
Also, Sie möchten einen Agenten bauen, der sich erinnert? Hier ist, was ich gelernt habe und was ich empfehle:
- Loggen Sie nicht einfach alles als reinen Text. Strukturieren Sie Ihre Gedächtniseinträge. Denken Sie daran, welche Informationen Sie später abfragen müssen, und gestalten Sie Ihr Schema entsprechend. JSON oder strukturierte Ereignisprotokolle sind Ihre Freunde.
- Implementieren Sie ein mehrschichtiges Gedächtnissystem. Kurzzeit-, episodisch, semantisch und reflektiv. Jede Schicht erfüllt einen anderen Zweck und verhindert eine Überlastung des Kontexts.
- Nutzen Sie Vektor-Datenbanken für die semantische Suche. Dies ist unerlässlich für eine effiziente Abfrage über große Gedächtnisspeicher. Betten Sie Ihre episodischen Einträge und semantisches Wissen für eine leistungsstarke Ähnlichkeitssuche ein.
- Gestalten Sie eine klare Abrufstrategie. Schütten Sie nicht einfach alles Gedächtnis in die Aufforderung. Lassen Sie den Agenten (oder ein kleineres Orchestrierungsmodell) entscheiden, welche Informationen basierend auf dem aktuellen Ziel und Kontext relevant sind.
- Beginnen Sie einfach, iterieren Sie und fügen Sie bei Bedarf Komplexität hinzu. Sie benötigen am ersten Tag nicht alle Schichten. Beginnen Sie mit episodischem Gedächtnis und einfachen semantischen Regeln, und bauen Sie die Reflexion aus, während sich Ihr Agent entwickelt.
- Destillieren Sie periodisch episodisches Gedächtnis in semantisches Wissen. Lassen Sie Ihren Agenten nicht in rohen Erfahrungen ertrinken. Ermutigen Sie ihn, zu verallgemeinern und Regeln zu lernen.
- Berücksichtigen Sie explizites Nutzerfeedback als Gedächtniseingabe. Wenn ein Benutzer sagt “Ich mag diesen Stil nicht,” speichern Sie es als Präferenz im semantischen Gedächtnis. Dies ist eine mächtige Lernform.
Wahre beständige und lernende Agenten zu bauen, ist eine Reise, kein Ziel. Es erfordert sorgfältige architektonische Planung und die Bereitschaft, zu experimentieren. Aber die Belohnung – ein Agent, der sein Fachgebiet wirklich versteht, aus seinen Fehlern lernt und sich im Laufe der Zeit verbessert – ist den Aufwand absolut wert. Mein Refactoring-Agent schlägt nach all dieser Arbeit nun proaktiv Verbesserungen basierend auf früheren Projektkonventionen vor und vermeidet die gleichen alten Fehler. Das ist ein echter Wendepunkt.
Was sind Ihre Erfahrungen mit dem Gedächtnis von Agenten? Lassen Sie es mich in den Kommentaren oder auf Twitter wissen! Immer interessiert daran zu hören, was andere aufbauen und lernen.
🕒 Published: