Tell a local model your name on Monday, open a new chat on Tuesday, and it has never met you. LM Studio’s documentation gives the reason in one line on its page about managing chats: “The model doesn’t ‘learn’ from chats.” The ability it lacks is called continual learning, and a 2017 paper in PNAS by researchers at DeepMind and Imperial College London defines it as the ability to learn consecutive tasks without forgetting how to perform the ones learned before. What follows is what that means, why a released model does not have it, and what does the remembering on a machine you run yourself.
What is continual learning, and why do language models lack it?
A language model is trained once and then shipped. On a local machine the result of that training is a file of weights, and it is the large number you see next to the model’s name. When we measured what a context window costs in RAM, LM Studio reported gemma-4-31B-it-QAT at 18.85 GB at every context setting we loaded, because that figure is the weights and nothing else.
Chatting does not add to it. The same LM Studio page says the model only knows the content that is present in the chat, or content supplied through configuration such as the system prompt. Close the chat and the model is exactly what it was before you opened it.
Continual learning would be the opposite arrangement: a model that keeps learning from new experience after release and keeps what it already knew. The PNAS paper, archived in full by the US National Library of Medicine, treats this as something brains do and artificial networks do not. It says humans and other animals appear to be able to learn in a continual fashion, and that for neural networks “little progress has been made in achieving continual learning”. That was the authors’ reading of their field in 2017, and we cite it as that. The LM Studio page describes a product that does not do it.
Why does training on new material cause catastrophic forgetting?
The obvious fix is to keep training. Take the released model, show it the new material, adjust the weights, repeat next week.
The PNAS paper explains why this fails. When a network is trained on one task and then on another, the weights that were important for the first task are changed to meet the objectives of the second, and knowledge of the first task is lost abruptly. The field calls this catastrophic forgetting. The authors show it on a sequence of handwritten digit classification tasks: with plain stochastic gradient descent the network forgot the first task, and the paper reports that the forgetting compounded with more training time and with each task added afterwards.
There is a known way to avoid it, and it is expensive. If the data from every task is available at once and mixed together during training, the paper says forgetting does not occur, because the weights can be optimised for all the tasks jointly. For a model learning from a stream of new experience, that means storing the old experience and replaying it. The authors call this impractical for large numbers of tasks, since in their setting the amount of stored memory would be proportional to the number of tasks.
Their own proposal is elastic weight consolidation, which slows down learning on the weights that matter most to earlier tasks. It worked, inside limits the authors state themselves. An agent with elastic weight consolidation learned 10 Atari games in sequence without catastrophic forgetting, and it did not reach the score that 10 separately trained networks would have reached.
Two cautions belong here. We read this paper and did not reproduce it. And its experiments are digit classifiers and game-playing agents, not language models, so what it gives a reader of this piece is the mechanism of catastrophic forgetting and not a ruling on any chat product.
If a model has no continual learning, what is its memory?
Text. LM Studio’s page says conversations are stored in JSON format in a conversations folder under ~/.lmstudio on Mac and Linux. What the application remembers is a transcript in a folder, and a transcript reaches the model the only way anything reaches it, which is as part of the prompt.
Anthropic’s documentation describes the same mechanism for a hosted model. Its page on context windows says the input for each turn contains all previous conversation history plus the current user message. It defines the context window as all the text a model can reference when it generates a response, including the response itself, and it separates that from the corpus the model was trained on. Its phrase for the window is a “working memory” for the model.
So a model that seems to remember your project is rereading it, every turn, from the top. That is a different thing from having learned it, and it comes with a bill that continual learning would not send. The memory has a fixed size and it occupies RAM.
Anthropic’s page adds a warning of its own: more context is not automatically better. It says accuracy and recall degrade as the token count grows, and it names the effect context rot. We report that as Anthropic’s statement about its models. We have not tested it.
What does the context window cost on a machine you run yourself?
We have measured parts of that bill on our test machine, an M4 Pro with 48 GB of unified memory.
The first is memory. A 64K context window on gemma-4-31B-it-QAT cost 4.4 GB of RAM more than an 8K one, at 80 KB for every token of context, and the model manager showed none of it. That rate belongs to that model, whose GGUF metadata predicted it. A different architecture will charge a different rate.
The second is the limit you did not choose. In our piece on why a local model stops at exactly 8,192 tokens, twelve benchmark runs ended early because LM Studio had loaded two models for us at its default context length, which on our install was 8,192 tokens. The prompt and the reply share that buffer. A model whose only memory is its context window had been handed a small one, and nothing in the response said so.
Standing instructions draw on the same budget. A persona file and a workspace guide are the closest thing an agent has to long-term knowledge, and they are paid for in tokens at the start of every session. When we counted the system prompt tokens in four files our agents load, the total was 38,922 tokens, which is 475 percent of an 8,192-token window.
How do agents work around the lack of continual learning?
They choose which text goes back in. The setup we described in infinite play by eviction is a clear example. It caps a 27B model at a 64K context, tries to hold the input near 32K by dropping the oldest messages, and never drops the system prompt. The facts of the game live in Python variables outside the conversation, and the model writes itself a short note that is copied into each new turn until the model overwrites it.
Anthropic documents two versions of the same idea. Its context windows page says chat interfaces can manage the window on a rolling first in, first out basis, and that server-side compaction summarises earlier parts of a conversation so it can continue past the limit.
Every one of these is an operation on text. Each decides what the model rereads. The PNAS paper is about a different operation entirely: changing weights without losing what they held.
The thing to check in any product that advertises memory is where the memory lives. If it is text that returns through the prompt, it is priced in tokens, and on the model we measured each token of context cost 80 KB.
