Warum KI-Tools wie Claude, Cursor und ChatGPT so schlecht im Erinnern sind
KI-Assistenten sind leistungsfähig, aber zwischen Tools geht das Wissen verloren: Kontext, der in Claude Code hinterlegt wurde, kennt Cursor ebenso wenig wie ChatGPT. Der fehlende gemeinsame Speicher ist ein strukturelles Problem aktueller KI-Werkzeuge.
Veröffentlicht am 10. Oktober • Ursprünglich erschienen auf 0xadityaa.dev
Das ist etwas, das mich schon länger gestört hat. Ich erzähle Claude Code, wie mein Projekt aufgebaut ist. Am nächsten Tag öffne ich Cursor und erkläre alles erneut. Dann füge ich denselben Absatz in ChatGPT ein, weil es natürlich auch keine Ahnung hat.
Diese Werkzeuge sind unheimlich schlau. Warum haben sie dann alle das Gedächtnis eines Goldfisches?
Ich bin der Sache nachgegangen, und die Antwort ist einfacher als erwartet: Ein Sprachmodell erinnert sich an nichts, niemals. Jede Gedächtnis-Funktion besteht darin, dass eine Anwendung Text in deinen Prompt einfügt, bevor das Modell ihn sieht. Sobald das klar ist, machen viele seltsame Verhaltensweisen plötzlich Sinn.
Nichts. Ein Modell ist eine Funktion. Text geht hinein, Text kommt heraus, und zwischen den Aufrufen behält es keinen Zustand.
Der Grund, warum sich ein Chat so anfühlt, als wäre er durchgehend, ist, dass die Anwendung bei jedem Drücken der Eingabetaste die gesamte Unterhaltung erneut sendet. All das muss in das Kontextfenster passen, also die feste Menge an Text, die ein Modell auf einen Blick betrachten kann. Wenn eine Unterhaltung zu lang wird, muss etwas weggelassen oder zusammengefasst werden, und genau dann "vergisst" es, was du vor einer Stunde gesagt hast.
Beginnst du einen neuen Chat, ist das Fenster wieder leer. Hallo, Goldfisch.
Wenn ein Tool behauptet, es erinnere sich an dich, passiert eigentlich Folgendes:
Genau das ist es. Es ist Retrieval-Augmented Generation, gerichtet auf deine eigenen Notizen. Das Modell erinnert sich nicht. Es liest einen Spickzettel, den ihm jemand zugeschoben hat.
Weil der Spickzettel in der Anwendung lebt, die ihn geschrieben hat.
ChatGPTs Notizen liegen auf OpenAIs Servern. Dein Editor hat seine eigene Regeldatei. Dein CLI-Agent hat eine andere Datei in einem anderen Format. Keine kann die Datei der anderen lesen, also wirst du zum Synchronisationsmechanismus und kopierst deinen eigenen Kontext herum wie anno 2005.
Genau diese Lücke stößt MCP an. Wenn Tools auf einen gemeinsamen Server zugreifen können, muss der Spickzettel nicht in jedem einzelnen davon leben.
Sätze zu speichern ist einfach. Der schwierige Teil ist Schritt zwei: auszuwählen, was eingefügt wird.
Fügst du zu wenig ein, kennt das Modell die Sache nicht. Fügst du zu viel ein, hast du dein Kontextfenster mit Nichtigkeiten verbrannt, und Modelle sind nachweislich schlechter darin, Dinge zu verwenden, die mitten in einem langen Prompt begraben sind.
Also wollte ich eine Zahl. Wie oft liefert eine Suche tatsächlich die Notiz zurück, die die Antwort enthält?
Ich habe nebenbei eine Memory-Schicht entwickelt (sie heißt Hivemind und ist die Idee des gemeinsamen Spickzettels aus dem letzten Abschnitt). Ich habe sie auf LoCoMo angesetzt, einen öffentlichen Benchmark mit langen Unterhaltungen und dazugehörigen Fragen, und drei Methoden verglichen, um pro Frage zehn Notizen auszuwählen. Dieselben 1.536 Fragen für jede Methode.
Alles einzufügen "gewinnt", und es ist eine Falle. Du findest die Antwort zu 99,7 Prozent, weil sie irgendwo darin steckt, unter 18.000 Tokens sonstigem Inhalt. Das kostet das Vierzigfache pro Frage, bei jeder einzelnen Frage.
Die Schlagwortsuche ist besser als ihr Ruf. 63,9 Prozent mit einem Algorithmus aus den Neunzigern. Sie ist schnell, sie ist günstig, und sie trifft exakte Namen und IDs, bei denen Embeddings unscharf werden.
Keine der beiden Suchen gewinnt allein. Die Fusion der beiden übertraf die bessere um neun Punkte. Sie versagen bei unterschiedlichen Fragen, also ergänzen sie sich gegenseitig.
Das ist Retrieval, nicht Antworten. "Die Notiz kam zurück" ist nicht "das Modell hat richtig geantwortet". Als ich die gesamte Schleife mit einem kleinen Modell, das antwortet, gemessen habe, sank die Genauigkeit deutlich. Die Notiz zu finden ist notwendig. Es ist nicht ausreichend.
Ein Benchmark, auf Englisch, offline ausgeführt. LoCoMo besteht aus lockeren Gesprächen. Deine Codebase-Notizen sind das nicht. Gegen den Live-Dienst erreichte dieselbe Pipeline bei einer kleineren Stichprobe 78,2 Prozent, und ich habe auch die Vorbehalte dazu aufgeschrieben.
Ich habe eine der Zeilen selbst gebaut. Ich habe versucht, den Vergleich fair zu halten: dieselben Fragen, derselbe Speicher, dieselbe Anzahl an Notizen. Du solltest das trotzdem im Wissen lesen, wer ihn durchgeführt hat.
Größere Kontextfenster ändern die Rechnung. Wenn die Fenster wachsen und die Tokens billiger werden, wird "alles einfügen" weniger absurd. Ich glaube nicht, dass es gewinnt, denn Aufmerksamkeit ist das knappe Gut, nicht Platz. Aber ich könnte mich darin irren, wo die Grenze am Ende liegt.
Deine KI-Werkzeuge haben keine schlechten Erinnerungen. Sie haben keine Erinnerungen, und darüber eine dünne Schicht aus Suchen-und-Einfügen, die zufällig in jeder Anwendung eingeschlossen ist.
Wenn du es selbst sehen willst, probier das: Nenne einem Tool eine Tatsache. Öffne ein anderes Tool und stelle eine Frage, die davon abhängt. Wo das scheitert, endet genau der Spickzettel, und jetzt weißt du auch, warum.
Automatisch übersetzt. Das Original auf Englisch ist unten aufklappbar.
Original (Englisch) anzeigen
Posted on Oct 10 • Originally published at 0xadityaa.dev
Here's something that kept bugging me. I tell Claude Code how my project is set up. The next day I open Cursor and explain it again. Then I paste the same paragraph into ChatGPT, because of course it has no idea either.
These tools are scary smart. So why do they all have the memory of a goldfish?
I went digging, and the answer is simpler than I expected: a language model doesn't remember anything, ever. Every "memory" feature is an app pasting text into your prompt before the model sees it. Once that clicks, a lot of weird behaviour starts to make sense.
Nothing. A model is a function. Text goes in, text comes out, and it keeps no state between calls.
The reason a chat feels continuous is that the app resends the whole conversation every time you hit enter. All of it has to fit in the context window, which is the fixed amount of text a model can look at in one go. When a conversation gets too long, something has to be dropped or summarised, and that's when it "forgets" what you said an hour ago.
Start a new chat and the window is empty again. Hello, goldfish.
When a tool says it remembers you, here's what's actually happening:
That's it. It's retrieval-augmented generation pointed at your own notes. The model isn't remembering. It's reading a cheat sheet somebody slipped it.
Because the cheat sheet lives inside the app that wrote it.
ChatGPT's notes sit on OpenAI's servers. Your editor keeps its own rules file. Your CLI agent has a different file in a different format. None of them can read each other's, so you become the sync mechanism, copy-pasting your own context around like it's 2005.
This is the gap MCP is nudging at. If tools can call out to a shared server, the cheat sheet doesn't have to live inside any one of them.
Saving sentences is easy. The hard part is step two: picking what to paste.
Paste too little and the model doesn't know the thing. Paste too much and you've burned your context window on trivia, and models are measurably worse at using stuff buried in the middle of a long prompt anyway.
So I wanted a number. How often does a search actually bring back the note that contains the answer?
I've been building a memory layer on the side (it's called Hivemind, and it's the shared cheat sheet idea from the last section). I pointed it at LoCoMo, a public benchmark of long conversations with questions about them, and compared three ways of picking ten notes per question. Same 1,536 questions for each.
Pasting everything "wins", and it's a trap. You find the answer 99.7% of the time because the answer is in there somewhere, under 18,000 tokens of everything else. That's forty times the cost per question, every question.
Keyword search is better than its reputation. 63.9% from an algorithm from the nineties. It's fast, it's cheap, and it nails exact names and IDs that embeddings blur.
Neither search wins alone. Fusing the two beat the better one by nine points. They fail on different questions, so together they cover for each other.
That's retrieval, not answers. "The note came back" isn't "the model answered right". When I measured the full loop with a tiny model answering, accuracy dropped a lot. Finding the note is necessary. It isn't sufficient.
One benchmark, in English, run offline. LoCoMo is chatty conversation. Your codebase notes aren't. Against the live service, on a smaller sample, the same pipeline scored 78.2%, and I wrote up the caveats for that one too.
I built one of the rows. I tried to keep the comparison fair: same questions, same store, same number of notes. You should still read it knowing who ran it.
Bigger context windows change the maths. As windows grow and tokens get cheaper, "paste everything" gets less silly. I don't think it wins, because attention is the scarce thing, not space. But I could be wrong about where the line ends up.
Your AI tools don't have bad memories. They have no memories, and a thin layer of search-and-paste on top that happens to be locked inside each app.
If you want to see it for yourself, try this. Tell one tool a fact. Open a different tool and ask a question that depends on it. Wherever that breaks is exactly where the cheat sheet stops, and now you know why.