Agent Memory & State

An LLM forgets everything between calls — memory is the layer you build on top so an agent stays coherent across turns. Short-term memory is the running conversation in the context window; long-term memory is what you write to an external store and pull back when it's relevant.

Where you meet it

A chat assistant that still knows your name and preferences three sessions later.
A coding agent that pauses at a checkpoint, gets approved, and resumes the same task tomorrow.
Long research or support flows where the transcript outgrows what fits in one prompt.

What it does

It gives a stateless model a place to keep what it learned. Short-term holds the live thread; long-term holds durable facts and past episodes. Together they let turn 10 act on something decided in turn 1 — even across separate sessions.

A bigger context window buys you a bigger bill and weaker attention — not memory. Real recall lives in an external store.

How it works

The model itself is stateless: each API call only sees the tokens you send. So "memory" is plumbing you add around it.

Short-term = the running conversation packed into the context window. Fast, but the window is finite and every token costs money and attention.
When the thread gets too long, you summarize (compaction): replace older turns with a compressed recap and start a fresh window from it.
Long-term = write facts to an external store — a key-value record or a vector database — and retrieve only the relevant pieces back into the prompt when needed.
What you store has flavors: semantic (facts: "user prefers metric"), episodic (past events: "last time we tried X, it failed"), procedural (how-to rules).

turn:    user says "I'm in Berlin"      → write to store: location=Berlin
later:   user asks "weather tomorrow?" → retrieve location=Berlin → answer
window full → summarize old turns → continue with the recap

Watch out

The context window is not memory. Anything that scrolls past the limit falls out — and a bigger window just means a bigger bill and weaker attention, not recall.
Summarizing loses detail. Compaction trades fidelity for room; the dropped specifics are gone unless they were also written to long-term store.
Retrieved memory can be wrong or stale. An old fact ("project is in planning") may no longer hold; the agent trusts it anyway.
Deciding what to keep vs forget is a real design choice — by relevance, and by privacy (don't persist what you shouldn't).
Consistency across sessions is hard. Two threads can write conflicting facts to the same store.

Go deeper

Ein LLM vergisst zwischen zwei Aufrufen alles — Gedächtnis ist die Schicht, die du darüber baust, damit ein Agent über Schritte hinweg kohärent bleibt. Kurzzeit-Gedächtnis ist die laufende Konversation im Kontextfenster; Langzeit-Gedächtnis ist das, was du in einen externen Speicher schreibst und bei Bedarf zurückholst.

Wo es vorkommt

Ein Chat-Assistent, der drei Sessions später noch deinen Namen und deine Präferenzen kennt.
Ein Coding-Agent, der an einem Checkpoint pausiert, freigegeben wird und morgen dieselbe Aufgabe fortsetzt.
Lange Recherche- oder Support-Abläufe, bei denen das Transkript größer wird, als in einen Prompt passt.

Was es tut

Es gibt einem zustandslosen Modell einen Ort für das Gelernte. Kurzzeit hält den laufenden Thread; Langzeit hält dauerhafte Fakten und vergangene Episoden. Zusammen lassen sie Schritt 10 auf etwas reagieren, das in Schritt 1 entschieden wurde — auch über getrennte Sessions hinweg.

Ein größeres Kontextfenster bringt höhere Kosten und schwächere Aufmerksamkeit — kein Gedächtnis. Echte Erinnerung lebt im externen Speicher.

Wie es funktioniert

Das Modell selbst ist stateless: Jeder API-Aufruf sieht nur die Tokens, die du mitschickst. "Gedächtnis" ist also Infrastruktur, die du drumherum baust.

Kurzzeit = die laufende Konversation, gepackt ins Kontextfenster. Schnell, aber das Fenster ist begrenzt, und jedes Token kostet Geld und Aufmerksamkeit.
Wird der Thread zu lang, wird zusammengefasst (Compaction): ältere Schritte durch eine komprimierte Zusammenfassung ersetzen und damit ein frisches Fenster starten.
Langzeit = Fakten in einen externen Speicher schreiben — einen Key-Value-Eintrag oder eine Vektor-Datenbank — und bei Bedarf nur die relevanten Stücke per Retrieval zurück in den Prompt holen.
Was du speicherst, hat Geschmacksrichtungen: semantisch (Fakten: "User bevorzugt metrisch"), episodisch (Ereignisse: "letztes Mal scheiterte X"), prozedural (Handlungsregeln).

Schritt:  User: "Ich bin in Berlin"      → in Speicher: ort=Berlin
später:   User: "Wetter morgen?"         → ort=Berlin abrufen → antworten
Fenster voll → alte Schritte zusammenfassen → mit dem Recap weiter

Worauf achten

Das Kontextfenster ist kein Gedächtnis. Was über die Grenze hinausläuft, fällt raus — und ein größeres Fenster heißt nur höhere Kosten und schwächere Aufmerksamkeit, nicht mehr Erinnerung.
Zusammenfassen verliert Details. Compaction tauscht Genauigkeit gegen Platz; die weggelassenen Details sind weg, außer sie wurden auch in den Langzeit-Speicher geschrieben.
Abgerufenes Memory kann falsch oder veraltet sein. Ein alter Fakt ("Projekt in Planung") stimmt vielleicht nicht mehr; der Agent vertraut ihm trotzdem.
Was behalten vs. vergessen ist eine echte Design-Entscheidung — nach Relevanz und nach Datenschutz (nicht speichern, was nicht gespeichert werden soll).
Konsistenz zwischen Sessions ist schwer. Zwei Threads können widersprüchliche Fakten in denselben Speicher schreiben.