Wie man einem KI-Agenten Gedächtnis gibt: State-Persistenz-Muster für die Produktion

Inhaltsverzeichnis

Aktualisiert Juni 2026.

TL;DR: Zustandslose Agenten — die Art, die beim Beenden des Workers alles vergisst — sind für einmalige Aufgaben in Ordnung. In dem Moment, in dem ein Agent sich erinnern muss, was gestern passiert ist, einen wiederkehrenden Kunden erkennen oder auf vorherigen Ausgaben aufbauen muss, braucht man Gedächtnis. Es gibt drei Muster: Arbeitsgedächtnis (In-Flight-Kontext, lebt für die Dauer eines Laufs in KV), episodisches Gedächtnis (was passiert ist und wann, ein abfragbares Protokoll) und semantisches Gedächtnis (was man weiß, abgerufen über Vektorsuche oder strukturierte Daten). Das richtige Muster an den richtigen Job koppeln.

[Operator-Perspektive] Ich bin mehr als einmal gegen die zustandslose Wand gestoßen. Der Social-Reply-Agent, der sich immer wieder bei Kunden vorstellte, mit denen er 20 Mal gesprochen hatte. Der Daily-Brief-Agent, der dasselbe Problem vier Tage in Folge meldete, weil er keine Erinnerung daran hatte, es gestern gemeldet zu haben. Den richtigen Gedächtnistyp hinzuzufügen, hat beides behoben. Das ist es, was ich verwende.

Warum zustandslose Agenten weiterhin scheitern

Ein zustandsloser Agent beginnt jeden Lauf nur mit dem, was man ihm explizit übergibt: den System-Prompt, die Benutzernachricht und alle Daten, die man zum Zeitpunkt der Aufrufung frisch abruft. Er hat kein Bewusstsein für frühere Läufe, frühere Benutzer oder frühere Entscheidungen.

Für eine einmalige Klassifizierungsaufgabe — einen Kommentar lesen, eine Kategorie zurückgeben — ist zustandslos korrekt. Es ist schnell, günstig und vorhersehbar.

Die Fehlerfläche tritt in dem Moment auf, in dem man Kontinuität benötigt:

• Ein kundenorientierter Agent, der die Geschichte des Kunden nicht erkennt
• Ein Content-Agent, der einen Artikel empfiehlt, den er letzte Woche bereits empfohlen hat
• Ein Moderationsagent, der einen gelösten Fall weiterhin eskaliert
• Ein Tagesbrief, der dauerhaft dieselbe veraltete Meldung anzeigt

All das sind Symptome desselben Problems: Der Agent hat keine Möglichkeit, Kontext über Läufe hinweg zu tragen.

Drei Arten von Gedächtnis

Das Rahmenwerk, das ich in der Produktion nützlich finde:

1. Arbeitsgedächtnis — was der Agent gerade jetzt weiß, während eines einzelnen Laufs. In KV oder im Speicher für die Lebensdauer der Aufrufung gehalten.
2. Episodisches Gedächtnis — was passiert ist und wann. Ein strukturiertes Protokoll, das der Agent zu Beginn jedes Laufs liest, um sich zu orientieren.
3. Semantisches Gedächtnis — was er über die Welt, Kunden oder eine Wissensbasis weiß. Bei Bedarf über strukturierte Abfragen oder Vektorsuche abgerufen.

Man braucht nicht immer alle drei. Die meisten Agenten, die ich betreibe, benötigen Arbeits- + episodisches Gedächtnis. Semantisches Gedächtnis ist das schwierigste zu bauen und verdient seinen Platz erst, wenn die Wissensbasis zu groß ist, um in das Kontextfenster zu passen.

Arbeitsgedächtnis: In-Flight-Kontext

Arbeitsgedächtnis ist Zustand, der für die Dauer eines Agentenlaufs lebt. Die einfachste Form sind Variablen im Funktionsumfang. Die interessantere Form ist ein gemeinsamer KV-Schlüssel, den Unteraufgaben innerhalb desselben Laufs lesen und schreiben.

Mein Social-Reply-Agent verwendet Arbeitsgedächtnis, um Kontext zu akkumulieren, während er einen Batch von Kommentaren in einer Queue-Nachricht verarbeitet. Er liest zu Beginn den letzten Gesprächsverlauf für jeden Kunden aus KV, fügt beim Verarbeiten neuen Kontext hinzu und schreibt am Ende zurück.

// workers/social-reply.ts

async function processComment(
  comment: SocialCommentEvent,
  env: Env
): Promise<void> {
  // Letzten Verlauf dieses Kunden aus KV laden (Arbeitsgedächtnis)
  const historyKey = `customer:${comment.userId}:history`;
  const rawHistory = await env.AGENT_KV.get(historyKey);
  const history: ConversationTurn[] = rawHistory
    ? JSON.parse(rawHistory)
    : [];

  // Kontextbewussten System-Prompt aus dem Verlauf aufbauen
  const systemPrompt = buildSystemPrompt(history);

  const response = await anthropic.messages.create({
    model: "claude-opus-4-8",
    max_tokens: 512,
    system: systemPrompt,
    messages: [{ role: "user", content: comment.text }],
  });

  const reply =
    response.content[0].type === "text" ? response.content[0].text : "";

  // Verlauf aktualisieren — letzte 10 Runden behalten, TTL 30 Tage
  const updatedHistory: ConversationTurn[] = [
    ...history.slice(-9),
    { role: "assistant", content: reply, timestamp: comment.timestamp },
  ];
  await env.AGENT_KV.put(historyKey, JSON.stringify(updatedHistory), {
    expirationTtl: 60 * 60 * 24 * 30,
  });

  await postReply(comment, reply, env);
}

Zwei Dinge sind zu beachten. Der Verlauf ist auf 10 Runden begrenzt — ein gleitendes Fenster einsetzen, es nicht unbegrenzt wachsen lassen. Und die TTL beträgt 30 Tage: Wenn ein Kunde einen Monat lang schweigt, läuft der Verlauf ab und der Agent fängt von vorne an. Beides ist absichtlich.

Episodisches Gedächtnis: was passiert ist und wann

Episodisches Gedächtnis ist das Protokoll des Agenten. Ein strukturierter Datensatz vergangener Läufe, den der Agent zu Beginn jedes neuen Laufs liest, um Wiederholungen zu vermeiden.

Mein Daily-Brief-Agent zeigte jeden Tag dieselben veralteten Meldungen, weil jeder Lauf kein Bewusstsein für das hatte, was bereits gemeldet worden war. Die Lösung: ein strukturiertes Protokoll vergangener Meldungen, das der Agent vor dem Erstellen des Briefs liest.

// workers/daily-brief.ts

interface AlertLogEntry {
  id: string;
  surfacedAt: string; // ISO-Zeitstempel
  resolvedAt?: string;
  summary: string;
}

async function buildDailyBrief(env: Env): Promise<void> {
  const [emails, calendar, tasks] = await Promise.all([
    fetchOvernightEmails(env),
    fetchTodayCalendar(env),
    fetchTopTasks(env),
  ]);

  // Episodisches Gedächtnis laden: was bereits gemeldet wurde
  const rawLog = await env.AGENT_KV.get("brief:alert-log");
  const alertLog: AlertLogEntry[] = rawLog ? JSON.parse(rawLog) : [];

  // Nur auf aktuelle, ungelöste Meldungen filtern
  const sevenDaysAgo = new Date(
    Date.now() - 7 * 24 * 60 * 60 * 1000
  ).toISOString();
  const recentAlerts = alertLog.filter(
    (e) => e.surfacedAt > sevenDaysAgo && !e.resolvedAt
  );

  const brief = await synthesizeBrief(
    { emails, calendar, tasks, recentAlerts },
    env
  );

  // Protokoll mit neuen Meldungen aus diesem Lauf aktualisieren
  const newAlerts: AlertLogEntry[] = brief.newAlerts.map((a) => ({
    id: crypto.randomUUID(),
    surfacedAt: new Date().toISOString(),
    summary: a,
  }));

  const updatedLog = [...alertLog, ...newAlerts].slice(-100); // letzte 100 behalten
  await env.AGENT_KV.put("brief:alert-log", JSON.stringify(updatedLog));

  await writeToWorkspace(brief.content, env);
}

Der Agent weiß jetzt, was er bereits gesagt hat. Doppelte Meldungen bleiben aus dem Brief heraus, bis sich das zugrunde liegende Problem ändert. Wenn ich eine Meldung als gelöst markiere, verschwindet sie von der aktiven Liste.

Dieses Muster lässt sich verallgemeinern: Jeder Agent, der Entscheidungen, Markierungen oder Empfehlungen produziert, profitiert von einem Protokoll. Das Protokoll ist günstig (ein paar KB in KV), der Gewinn ist hoch (keine redundanten Ausgaben mehr).

Semantisches Gedächtnis: was man weiß

Semantisches Gedächtnis ist die Wissensbasis. Es beantwortet zur Abfragezeit „Was weißt du über X?”, anstatt alles vorab in den System-Prompt zu packen.

Die einfachste Form ist eine strukturierte Suche in KV oder einer Datenbank. Mein Pickleland-Buchungsagent ruft Kundenprofile und Platzpräferenzen auf, bevor er Bestätigungen entwirft:

// workers/booking-agent.ts

interface CustomerProfile {
  userId: string;
  preferredCourts: string[];
  experienceLevel: "beginner" | "intermediate" | "advanced";
  specialNotes: string;
}

async function draftConfirmation(
  booking: BookingEvent,
  env: Env
): Promise<string> {
  // Kundenprofil aus KV abrufen (semantisches Gedächtnis — faktisches Wissen)
  const profileKey = `customer:${booking.userId}:profile`;
  const rawProfile = await env.AGENT_KV.get(profileKey);
  const profile: CustomerProfile | null = rawProfile
    ? JSON.parse(rawProfile)
    : null;

  const systemPrompt = profile
    ? `Du erstellst personalisierte Buchungsbestätigungen. Dieser Kunde bevorzugt ${profile.preferredCourts.join(", ")}, ist ein ${profile.experienceLevel}-Spieler. ${profile.specialNotes}`
    : "Du erstellst Buchungsbestätigungen für eine Pickleball-Anlage.";

  const response = await anthropic.messages.create({
    model: "claude-haiku-4-5-20251001",
    max_tokens: 256,
    system: systemPrompt,
    messages: [
      {
        role: "user",
        content: `Erstelle eine Bestätigung für: ${JSON.stringify(booking)}`,
      },
    ],
  });

  return response.content[0].type === "text" ? response.content[0].text : "";
}

Für größere Wissensbasen — Produktdokumentation, eine Support-Wissensbasis, alles zu Große, um in ein Kontextfenster zu passen — braucht man einen Vektorspeicher. Der Arbeitsablauf ist: die Abfrage einbetten, die k relevantesten Chunks abrufen, sie in den Kontext einfügen. Cloudflare Vectorize erledigt das nativ, wenn man bereits auf Workers ist. Für größere Indizes habe ich Upstash Vector verwendet. Die Wahl hängt vom Umfang ab, nicht vom Prinzip.

Der ehrliche Hinweis zum semantischen Gedächtnis: Es ist das schwierigste der drei zu bauen und zu pflegen. Der Index muss aktuell bleiben. Die Abrufqualität variiert. Mit strukturierten Suchen beginnen — KV, eine Tabelle in D1 — und nur zur Vektorsuche greifen, wenn der strukturierte Ansatz die benötigte Wissensoberfläche nicht abdecken kann.

Das Gedächtnis-Entscheidungsrahmenwerk

Bevor man einem Agenten Gedächtnis hinzufügt, drei Fragen beantworten:

1. Muss sich der Agent über Läufe hinweg erinnern? Wenn jede Aufrufung genuinen unabhängig ist — eine Übersetzung, eine Klassifizierung, eine einmalige Generierung — Gedächtnis weglassen. Zustandslos ist einfacher und günstiger.

2. Wiederholt sich der Agent oder handelt er blind gegenüber seiner eigenen Geschichte? Wenn ja, zuerst episodisches Gedächtnis hinzufügen. Es ist die Korrektur mit dem geringsten Aufwand und deckt die meisten Beschwerden über „der Agent macht X immer wieder” ab.

3. Behandelt der Agent jeden Benutzer oder jede Entität identisch, obwohl er es nicht sollte? Wenn ja, Arbeitsgedächtnis (Kundenverlauf, Benutzerprofil) oder semantisches Gedächtnis (ein Such- oder Abrufsystem) hinzufügen.

Der Fehler, den ich am häufigsten sehe: Jemand fügt eine riesige Wissensbasis (semantisches Gedächtnis) zu einem Agenten hinzu, der in Wirklichkeit scheiterte, weil er kein episodisches Gedächtnis hatte — kein Protokoll darüber, was er bereits getan hatte. Die Komplexität passt nicht zum Problem.

Was ich in der Produktion tatsächlich verwende

Bei 30+ Agenten:

• Alle haben mindestens Arbeitsgedächtnis — irgendeine Form von Zustand innerhalb eines Laufs, auch wenn es nur das Kontextfenster selbst ist.
• Etwa die Hälfte hat episodisches Gedächtnis — ein Protokoll vergangener Läufe, Entscheidungen oder Markierungen. Dies lohnt sich fast immer hinzuzufügen.
• Drei oder vier haben echtes semantisches Gedächtnis, das von einem Vektorspeicher unterstützt wird. Das sind die Agenten, die Fragen zu einer großen, dynamischen Wissensbasis beantworten.

Cloudflare KV ist mein Standard-Speicher für Arbeits- und episodisches Gedächtnis. Es ist schnell, günstig und nativ in Workers integriert — kein zusätzlicher Client, keine separate Anmeldeinformation. Die Einschränkung: KV ist eventuell konsistent und nicht gut für hochfrequente Schreibvorgänge geeignet. Für Agenten, die mehrmals pro Sekunde Zustand schreiben, verwende ich stattdessen Durable Objects oder eine D1-Datenbank.

Für semantisches Gedächtnis, das von Vektoren unterstützt wird, verwende ich Cloudflare Vectorize für kleine bis mittlere Indizes (unter ~100K Vektoren) und Upstash Vector für alles Größere. Beide haben erstklassige JavaScript-Clients.

Das Fazit des Operators

Einem Agenten nur dann Gedächtnis hinzufügen, wenn zustandsloses Verhalten echte Probleme verursacht — wiederholte Ausgaben, blinde Flecken bei der Kundengeschichte, Unkenntnis vergangener Entscheidungen. Dann die richtige Schicht wählen: Arbeitsgedächtnis für den laufenden Kontext, episodisch für das, was historisch passiert ist, semantisch für das, was man weiß. Mit episodisch beginnen, wenn man unsicher ist — es behebt den häufigsten Fehlermodus mit der geringsten Komplexität. Keine Vektordatenbank verwenden, bis man strukturierte Suchen ausgeschöpft hat. Das beste Gedächtnissystem ist das einfachste, das den Agenten korrekt verhalten lässt.

Verwandt: Der Agent-Stack, den ich für 30+ Produktionsagenten nutze · Ereignisgesteuerte vs. geplante Agenten · Wie ich messe, ob ein KI-Agent wirklich funktioniert

Brauchen Sie Hilfe bei der Gestaltung von Agentengedächtnis für Ihren Anwendungsfall? Kontaktieren Sie mich — ich entwerfe Produktionsagentensysteme für Operator-Teams.