Warum Claude Code zwischen Sessions vergisst und wie sich unseres erinnert

Claude Code vergisst den Kontext zwischen Sessions, weil jede Session mit einem leeren Kontextfenster beginnt. Innerhalb einer Session wird ein volles Fenster komprimiert: Ältere Gesprächsrunden werden zu einer Zusammenfassung. Zwischen Sessions bleibt nichts erhalten außer dem, was aufgeschrieben wurde.

Sessionübergreifendes Gedächtnis ist eine Routine, die einen KI-Coding-Agenten vor der Arbeit frühere Entscheidungen nachschlagen und danach neue speichern lässt, sodass ein frisches Kontextfenster informiert startet. Wir betreiben es als Schleife in Claude Code, durchgesetzt von einem Stop-Hook (einem Skript, das Claude Code jedes Mal ausführt, wenn es eine Antwort beendet). OpenCode und Kimi Code teilen dieselben Regeln und denselben Speicher.

Innerhalb einer Session werden ältere Runden komprimiert; zwischen Sessions startet das neue Fenster leer, und nur gespeicherte Notizen kommen hinüber.

Warum Claude Code vergisst und was unsere Gedächtnisschleife tut

Claude Code vergisst nicht aus Versehen. Jede Session startet bewusst leer, deshalb ist die Lösung eine Routine, keine größere Datei.

Anthropics Dokumentation(wird in einem neuen Tab geöffnet), 2026: „Jede Claude-Code-Session beginnt mit einem frischen Kontextfenster.“ Zwei eingebaute Funktionen geben Claude Code ein Gedächtnis über Sessions hinweg:

Kontext ist etwas, das der Agent abwägt, kein Schritt, den er ausführen muss. Deshalb haben wir eine Schleife darübergelegt, mit einem gemeinsamen Speicher, den der Agent über MCP erreicht:

Der Speicher ist unser Unternehmensgedächtnis; wie Notizen sortiert werden, ist Schicht 1 unseres selbstverbessernden Systems.

Die kopierbare Version (Hook, Eintrag in settings.json und Test) steht unter Eine eigene Gedächtnisschleife bauen.

Warum wir sie gebaut haben: Eine schriftliche Regel wird übersprungen

Wir haben die Regel aufgeschrieben, und der Agent hat sie übersprungen. Eine Regel, die davon abhängt, dass der Agent an sie denkt, ist ein Vorschlag.

Die Regel stand in der Anweisungsdatei: vor dem Erkunden nachschlagen, danach speichern. Sessions übersprangen das Nachschlagen und lasen Code erneut, den eine frühere Session schon kartiert hatte. Sessions bearbeiteten Dateien und endeten, ohne etwas aufzuschreiben, sodass die nächste dieselbe Antwort neu entdeckte.

Das Gedächtnis existierte, und die Tools funktionierten. Was fehlte, war ein Moment, in dem das Überspringen etwas kostete. Eine Person gibt die Arbeit frei, auf die es ankommt (unser Governance-Modell), aber niemand sieht jedem Session-Ende zu.

Sehen Sie, wie ConvOps allen Agenten ein gemeinsames Gedächtnis gibt, das sie vor der Arbeit prüfen(wird in einem neuen Tab geöffnet), und die Notizen bewahrt, die jede Session hinterlässt.

Wie die Gedächtnisschleife läuft

Abrufen kostet einen Aufruf. Speichern kostet einen Aufruf. Aufwendig ist nur, dafür zu sorgen, dass beides jedes Mal passiert, und genau diese Aufgabe haben wir dem Hook gegeben.

Bei jedem geprüften Stopp schicken Änderungen ohne Speicherung den Agenten zum Speichern zurück; andernfalls endet die Session.

Wie ein Stop-Hook entscheidet. Er liest das Transkript (die Datei, in der Claude Code jede Nachricht und jeden Tool-Aufruf protokolliert) und endet mit einem Exit-Code, einer Zahl, die Claude Code sagt, was als Nächstes passiert. Exit 0 lässt die Session enden. Exit 2 „verhindert, dass Claude stoppt, und setzt die Unterhaltung fort“ (Anthropic, Hooks(wird in einem neuen Tab geöffnet), 2026), und der Agent liest die Meldung des Hooks. Unser Löschschutz nutzt denselben Exit-Code bei Tool-Aufrufen.

Was der Gedächtnis-Stop-Hook prüft

Jeder Schwellenwert hier ist der, mit dem unser Hook läuft.

Jede verletzte Regel fügt eine Meldung hinzu, die Blockade endet mit „This is mandatory.“, und der Hook endet mit Exit 2.

Was der Hook nicht sieht

Wir vertrauen dem Hook mehr, weil wir genau wissen, wo er blind ist.

• Er zählt Tool-Aufrufe nach Namen. Er liest nie, was ein Abruf zurückgegeben hat oder ob eine Speicherung etwas taugte.
• Nur memory_store zählt als Speicherung. Eine Session, die nur context=-Notizen schreibt und Dateien bearbeitet, wird trotzdem zurückgeschickt.
• Änderungen über die Shell bleiben unsichtbar. Ein sed oder ein Heredoc ist für den Hook keine Änderung; nur die vier nativen Bearbeitungs-Tools zählen.
• Das Transkript kann hinterherhinken. Laut Anthropics Hooks-Dokumentation(wird in einem neuen Tab geöffnet) wird es asynchron geschrieben, sodass eine Speicherung im letzten Moment erst bei der nächsten Prüfung gezählt wird.
• Er läuft nur in Claude Code; siehe die Abschnitte zu OpenCode und Kimi Code.

Hooks enthalten die Regeln, die nie vom Gedächtnis abhängen dürfen (die Hook-Schicht). Dieser hier erzwingt die Aufrufe, nicht das Gedächtnis.

Wie sich Claude Code zwischen Sessions erinnert

Der nützliche Moment ist nicht das Speichern. Es ist der nächste Morgen, wenn eine Session, die die Arbeit vom Montag nie gesehen hat, mit der Lektion vom Montag beginnt.

Copperfern ist ein erfundener Online-Shop für Wohnaccessoires; Namen, Dateien und Notizen sind erfunden, Schwellenwerte und Meldungen sind echt.

Montag. Maya, die den Betrieb leitet, legt einen Task an: „Spanische Bestellungen weichen an der Kasse um einen Cent ab.“ Der Coding-Agent führt context_query("spanish vat checkout rounding") aus und findet nichts zur Rundung. Er liest shop/checkout/tax.py, sieht, dass die Mehrwertsteuer einmal auf die Bestellsumme gerundet wird, ändert die Datei und ihren Test so, dass pro Position gerundet wird, und versucht zu stoppen.

Der Hook läuft: 5 Tool-Aufrufe, genug neue Einträge seit der letzten Prüfung. Ein Nachschlagen hat stattgefunden, also schlägt nur die Änderungsprüfung an:

KNOWLEDGE CHECK: Modified 2 file(s) but stored nothing. memory_store() the change/decision (supersede if updating). If you explored files, create_route()/update_route() in ConvOps. This is mandatory.

Exit 2. Der Agent speichert eine Stolperfalle, Wichtigkeit 7, Tags shop, checkout, vat. Die Notiz lautet: „Die spanische Mehrwertsteuer wird pro Position gerundet, nicht auf die Bestellsumme; wer die Summe rundet, liegt bei Bestellungen mit mehreren Artikeln um einen Cent daneben.“ Er legt eine Route an: „Die Rundung der Mehrwertsteuer liegt in shop/checkout/tax.py“. Er stoppt erneut. stop_hook_active ist true, und die Session endet.

Die Session am Montag behebt die Rundung, wird einmal zurückgeschickt und speichert das Warum, bevor sie endet.

Dienstag. Ein neuer Task: „Mehrwertsteuer auf die Position Geschenkverpackung aufschlagen.“ Neue Session, leeres Fenster: Nichts vom Montag ist darin. Der Agent führt context_query("vat gift wrap checkout") aus, und die Stolperfalle vom Montag samt Route kommt zurück. Er öffnet shop/checkout/tax.py direkt und rundet die Mehrwertsteuer der Geschenkverpackung auf ihrer eigenen Position.

Auch der Versand erweist sich als eigene Position. Der Agent speichert die verfeinerte Stolperfalle („Die spanische Mehrwertsteuer wird pro Position gerundet; Geschenkverpackung und Versand zählen jeweils als eigene Position.“) und vergisst dann den Eintrag vom Montag mit memory_forget, einem umkehrbaren Soft Delete. Beim Stopp kam das Nachschlagen vor dem Speichern, und zur Änderung gibt es eine Speicherung: Exit 0. Nur die verfeinerte Notiz beantwortet das nächste Nachschlagen.

Die Session am Dienstag hat den Montag nie gesehen, doch ihr erstes Nachschlagen liefert die Lektion vom Montag; sie speichert die verfeinerte Notiz und vergisst die alte.

Was die Schleife hinterlässt

Ein Gedächtniseintrag ist genau so viel wert, wie die nächste Session ohne Rückfrage damit anfangen kann: ein Fakt, sein Grund, ein Typ und eine ehrliche Wichtigkeit.

Ein Gedächtniseintrag, wie der Agent ihn speichert:

content:    Spanish VAT rounds per line, not per order total; rounding the
            total is off by a cent on multi-item orders.
category:   gotchas
importance: 7
tags:       shop, checkout, vat
task_id:    cf-131

Der Inhalt enthält den Fakt und seinen Grund. Die Wichtigkeit gibt an, wie viel die nächste Session verliert, wenn sie die Notiz übersieht: Die meisten liegen bei 4 bis 6, und diese ist eine 7, weil eine falsche Summe bei Kunden ankommt. Zwei bis fünf Tags machen sie auffindbar.

Eine Route sagt, wo etwas liegt:

title:       VAT rounding
description: VAT rounding lives in shop/checkout/tax.py
paths:       shop/checkout/tax.py, tests/test_tax.py

Eine context=-Notiz wird im selben Aufruf wie ein Task-Update geschrieben und als ein mit dem Task verknüpfter Gedächtniseintrag gespeichert (standardmäßig mit Wichtigkeit 4; unter 40 Zeichen wird sie nicht gespeichert):

Rounded VAT per line, not per order; Spanish totals were a cent off on
multi-item orders.

Kein Feld ersetzt einen Eintrag. Der Agent speichert die neue Notiz und vergisst die alte. Eine Person kann eine Notiz auch auf der Brain-Seite ersetzen, die den neuen Eintrag mit dem alten verknüpft und den alten aus dem Abruf nimmt.

Was bei einem Gedächtnis-Hook schiefgeht

Unsere Durchsetzung ist zweimal gescheitert, in entgegengesetzte Richtungen: einmal ließ sie Änderungen stillschweigend durch, einmal blockierte sie für immer. Prüfen Sie Ihren eigenen Hook auf beides.

Er ließ Änderungen durch. Die einzige Prüfung auf „nichts gespeichert“ wartete, bis eine Session eine Mindestlänge erreicht hatte. Eine kurze Copperfern-Session ändert die Vorlage für Versandetiketten und endet sauber, ohne etwas aufzuschreiben; die nächste Session wiederholt dieselbe Untersuchung. Die Regel, die daraus entstand: Änderungen ohne Speicherung werden bei der nächsten Prüfung gemeldet, ohne diese Wartezeit. Die Untergrenze von 3 Aufrufen und das Intervall gelten weiterhin.

Er blockierte für immer. Die Prüfung „Speichern vor Abruf“ verglich die erste Speicherung mit dem ersten Abruf über die gesamte Session. Eine Session speichert eine Notiz vor ihrem ersten Nachschlagen, schlägt danach korrekt nach und wird trotzdem bei jedem Stopp zurückgeschickt, bis sie abgebrochen wird. Die Regel, die daraus entstand: Jede Prüfung betrachtet nur, was seit der letzten Prüfung passiert ist, sodass ein früher Ausrutscher bei der Prüfung gemeldet wird, die ihn abdeckt, nicht bei jedem späteren Stopp.

Unser Code-Kommentar sagt, warum: „Ein Flag, das kein späteres Verhalten erfüllen kann, ist Nörgelei, kein Schutz.“ Für diese Regel gibt es jetzt einen Test, der den echten Hook mit einem synthetischen Transkript ausführt, einem nachgebauten Session-Log.

Vor der Korrektur blockierte eine frühe Speicherung jeden späteren Stopp; jetzt betrachtet jede Prüfung nur, was seit der letzten passiert ist, sodass der Ausrutscher in seinem eigenen Fenster gemeldet wird.

Wir haben die Nachschlageregel eingegrenzt. Früher galt sie für jede Nachricht. Jetzt gilt sie, bevor etwas erkundet oder bearbeitet wird, das noch nicht bekannt ist; das Speichern nach jeder Aktion bleibt Pflicht. Eine Session, die gefragt wird, wie spät es in Madrid ist, schlägt nichts nach; eine Session, die gleich den Checkout-Code liest, immer.

Eine eigene Gedächtnisschleife in Claude Code bauen

Beginnen Sie mit einer Regel, die der Hook zählen kann: Wenn eine Session Dateien geändert hat, schreibt sie auf, was und warum, bevor sie endet.

Verbinden Sie zuerst den Speicher. Wir nutzen ConvOps; ein Befehl fügt ihn zu Claude Code hinzu:

claude mcp add --transport http convops https://mcp.convops.app/

Fügen Sie dann diese zwei Zeilen in Ihre CLAUDE.md ein. Halten Sie die Datei kurz (was Sie aus einer langen CLAUDE.md streichen): Der Hook trägt die Durchsetzung, die Datei trägt die Gewohnheit.

Before exploring or working on anything you don't already know, query the memory store first. Known answers and chat skip the lookup.
After every action, store what you learned and why, with a type, an honest importance and two to five tags. To replace a note, store the new one, then forget the old one.

Diese reduzierte Fassung unseres Hooks (Claude Code 2.1.301) behält den Schleifenschutz, die Untergrenze von 3 Aufrufen, das Intervall, die Änderungsprüfung und das Nachschlagen bei der ersten Prüfung. Speichern Sie sie als ~/.claude/hooks/memory-gate.py:

"""Stop hook: send the agent back when it edited files and stored nothing."""
import json, os, sys, tempfile

MIN_TOOL_CALLS = 3
INTERVAL = 2
EDIT_TOOLS = ("Edit", "Write", "MultiEdit", "NotebookEdit")

hook = json.load(sys.stdin)
if hook.get("stop_hook_active"):
    sys.exit(0)  # the retry after a block is not checked
names, entries = [], 0
with open(hook["transcript_path"]) as f:
    for line in f:
        entry = json.loads(line)
        if entry.get("type") != "assistant":
            continue
        entries += 1
        for block in entry.get("message", {}).get("content", []):
            if isinstance(block, dict) and block.get("type") == "tool_use":
                names.append(block["name"])

if len(names) < MIN_TOOL_CALLS:
    sys.exit(0)
counter = os.path.join(tempfile.gettempdir(), f"memory_gate_{hook['session_id']}")
last = int(open(counter).read()) if os.path.exists(counter) else 0
if entries - last < INTERVAL:
    sys.exit(0)
open(counter, "w").write(str(entries))
edits = sum(n in EDIT_TOOLS for n in names)
stores = sum("memory_store" in n for n in names)
lookups = sum("context_query" in n or "route_query" in n for n in names)
problems = []
if edits and not stores:
    problems.append(f"Modified {edits} file(s) but stored nothing. Store the change and why.")
if last == 0 and not lookups:
    problems.append("No lookup at the first check. Query the memory store first.")
if problems:
    print("KNOWLEDGE CHECK: " + " | ".join(problems) + " This is mandatory.", file=sys.stderr)
    sys.exit(2)

Registrieren Sie ihn unter Stop in .claude/settings.json:

{
  "hooks": {
    "Stop": [
      {
        "hooks": [
          { "type": "command", "command": "python3 ~/.claude/hooks/memory-gate.py", "timeout": 15 }
        ]
      }
    ]
  }
}

Testen Sie ihn mit einem synthetischen Transkript, bevor Sie ihm vertrauen. Dieses enthält ein Nachschlagen und zwei Änderungen, erwartet also Exit 2:

printf '%s\n' \
  '{"type":"assistant","message":{"content":[{"type":"tool_use","name":"context_query"}]}}' \
  '{"type":"assistant","message":{"content":[{"type":"tool_use","name":"Edit"}]}}' \
  '{"type":"assistant","message":{"content":[{"type":"tool_use","name":"Edit"}]}}' \
  > copperfern-test.jsonl
echo '{"session_id":"test-001","transcript_path":"copperfern-test.jsonl"}' \
  | python3 ~/.claude/hooks/memory-gate.py; echo "exit $?"

Verwenden Sie pro Lauf eine neue session_id, denn die Zählerdatei merkt sich die letzte Prüfung. Fügen Sie dann eine memory_store-Zeile hinzu und erwarten Sie Exit 0.

Gedächtnis zwischen Sessions in OpenCode

Sessions in OpenCode 1.18.31 starten ebenfalls leer. Wir geben ihnen denselben Text und denselben Speicher.

Unsere AGENTS.md-Dateien sind Symlinks auf CLAUDE.md, sodass OpenCode dieselben Regeln zum Abrufen und Speichern liest (eine Datei für beide). Unsere opencode.json richtet ihren mcp-Block auf denselben ConvOps-Speicher, sodass eine in Claude Code gespeicherte Notiz bei einem Nachschlagen in OpenCode zurückkommt. In OpenCode betreiben wir keinen Gedächtnis-Hook. Es bietet eine Plugin-Schnittstelle dafür (Plugins(wird in einem neuen Tab geöffnet)); unser Löschschutz zeigt, wie so ein Hook aussieht.

Gedächtnis zwischen Sessions in Kimi Code

Kimi Code 0.31.1 erhält denselben Text und denselben Speicher. Es liest die per Symlink verknüpfte AGENTS.md, und unsere .kimi-code/mcp.json führt denselben ConvOps-Server, sodass seine Abfragen zurückliefern, was Claude Code und OpenCode gespeichert haben. In Kimi Code betreiben wir keinen Gedächtnis-Hook. Es nimmt [[hooks]]-Einträge in seiner Benutzerkonfiguration an (Kimi-Code-Hooks(wird in einem neuen Tab geöffnet)), und die Anleitung zum Löschschutz zeigt einen.

Erstellen Sie ein kostenloses ConvOps-Konto und verbinden Sie Claude Code, OpenCode oder Kimi Code mit einem gemeinsamen Gedächtnis(wird in einem neuen Tab geöffnet), und fügen Sie dann die Nachschlageregel, die Speicherregel und den Stop-Hook hinzu.