DeepSeek's Engram: Teaching AI to Remember Like Humans Do

Have you ever thought about how people remember things?

When you see the phrase "the capital of France," do you have to think hard? No. You immediately know it's Paris. The answer jumps out from your memory like a fish leaping from water, effortlessly.

But strangely, today's AI doesn't work this way. Every time ChatGPT or other large language models see "the capital of France," they must compute the answer from scratch. Every single time. It's like having a brilliant friend who solves every math problem from first principles, never remembering that 2+2=4. You might ask: isn't that kind of silly? It is.

Why does this happen? To understand, we need to start with how large language models work.

Today's large language models, like GPT, Claude, and DeepSeek, store everything they learn in numbers called "parameters." You can think of parameters as neural connections in the model's brain. A model has tens or even hundreds of billions of parameters, each one a small number, and together they form the model's "knowledge."

The problem is that all these parameters must live in GPU memory. GPUs are specialized chips that run AI, and their memory is very expensive and limited in capacity. A top-of-the-line NVIDIA H100 GPU has only 80GB of memory. A 70-billion parameter model needs about 140GB just to store the parameters. This means you need two GPUs before you even start doing any work.

Think of it this way: current AI is like a person who carves all their knowledge onto gold tablets, then locks all the tablets in a very small, very expensive vault. Want more knowledge? You need more gold tablets, a bigger vault, and costs go up fast.

But DeepSeek's researchers discovered something crucial: not all knowledge needs to be stored this way.

Let's think carefully about what models actually learn. Some of it is genuinely complex, like how to understand the meaning of a sentence, how to organize several ideas coherently, how to make judgments based on context. These abilities require flexible computation because every situation is different.

But a large portion of knowledge is actually quite simple, just fixed facts and patterns. What words typically follow "New York"? What kind of sentences does "machine learning" usually appear in? The capital of France is Paris. These things don't change based on context. They're fixed.

So here's the question: why store these two completely different types of knowledge the same way? The abilities that require flexible computation should indeed use expensive GPU parameters. But those fixed facts and patterns, why not put them somewhere cheaper and just look them up when needed?

This is the core idea of Engram.

Engram is a new technology released by DeepSeek in January 2026. The name comes from neuroscience. In brain research, an "engram" refers to the physical trace of a memory in the brain, a pattern of neural connections that encodes specific information. DeepSeek borrowed this concept to build a system dedicated to storing pattern memories for AI.

Simply put, Engram adds a "memory notebook" to AI. Those frequently occurring fixed patterns, like common word combinations, are pre-stored and looked up when needed, rather than recomputed every time.

This system has four key components. Let me explain them one by one.

First, fast lookup for common patterns. The heart of Engram is a huge table that stores common word combinations. Take "climate change" for example. In traditional models, every time these two words appear, the model spends significant computational resources understanding their relationship. But in Engram, this common combination is pre-computed and stored in the table. You just look it up. This lookup is extremely fast. No matter how big the table gets, lookup time stays about the same, just like looking up a word in a dictionary. It doesn't matter how thick the dictionary is once you find the right page.

Second, vocabulary standardization. The same meaning can be written many ways. "Running," "running," and "RUNNING" are the same word. "Café" and "cafe" mean the same thing. Engram standardizes these different forms, so you don't need to store multiple versions of the same concept. This saves about 23% of storage space. More importantly, it helps the model learn better because it knows these are actually the same thing.

Third, handling lookup conflicts. Using tables for lookup has a problem: sometimes two different word combinations might point to the same location in the table. It's like two people having the same phone number. Engram's solution is to use several lookup systems simultaneously, like a library that's organized by author name, book title, and publication date all at once. If one system has a problem, the others still work.

Fourth, an intelligent switch. Not every situation calls for checking the memory notebook. Sometimes you encounter a common situation, and checking memory works great. Sometimes you encounter something new, and the model needs to think carefully. Engram has an automatically learned switch that decides when to check memory and when to compute from scratch. If it thinks the retrieved content might not be reliable, it automatically switches to computation mode.

At this point, you might ask: where is this "memory notebook" stored?

This is perhaps the most interesting aspect of Engram. In experiments, DeepSeek stored the memory notebook together with model parameters, all in GPU memory. But the design is actually quite flexible. Checking the memory notebook and doing neural network computation have different hardware requirements. Neural network computation needs to read large amounts of data simultaneously, requiring high bandwidth. Memory lookup only reads a small amount of data each time. It doesn't need high bandwidth but requires fast response.

This difference means the memory notebook can be stored outside GPU memory. It could go in regular computer memory (much cheaper than GPU memory), on high-speed drives, or even on other machines. The paper explicitly states that static memory can be stored outside the GPU at very low cost.

What does this mean in practice? Imagine a model keeping the parts that need "thinking" (like understanding context and reasoning) in expensive GPU memory, while putting gigabytes or even tens of gigabytes of the "memory notebook" in cheaper regular memory. The model stays smart, but hardware costs drop significantly.

So how well does this actually work?

DeepSeek trained several models for comparison. One traditional model with 4 billion parameters, one Mixture of Experts model (MoE) with 26.7 billion parameters, and one with the same size but with Engram added. All models were trained on the same data under fully comparable conditions.

The results were clear. On knowledge Q&A tests, the Engram model scored 3 to 4 points higher than the traditional model of the same size. On reasoning tests, it improved by 5 points. Coding tests and math tests also showed improvements.

The most dramatic improvement came in long document processing. There's a test called "Needle in a Haystack," which involves finding a specific piece of information in a very long article. The traditional model achieved about 84% accuracy, while the Engram model reached 97%. This is a huge improvement.

Why? When processing long documents, models need to pay attention to many things at once, and attention resources get spread thin. If the model also needs to use attention to recall those fixed patterns, even less attention remains for the truly important tasks. Engram hands off fixed pattern recall to the memory notebook, so the model can focus all its attention on what actually requires thinking.

DeepSeek also conducted in-depth analysis. They found Engram works best when placed in the early layers of the network. This makes sense because early layers mainly handle word and pattern level processing, while later layers do more abstract reasoning. They also found that if you turn off Engram after training, performance on fact-based Q&A drops dramatically, with accuracy falling by 29%. This shows the model has genuinely learned to rely on the memory notebook for fixed knowledge.

Perhaps the most interesting finding: even without increasing computation, just increasing the size of the memory notebook keeps improving model performance. This hints at the possibility of "infinite memory." Unlike increasing model parameters, increasing memory costs very little, and the benefits are lasting.

Engram reveals something profound about AI. Over the past few years, we've been improving AI capabilities by adding more parameters. More parameters means stronger computational ability, but also higher hardware costs. Engram shows that computational ability and memory ability can be considered separately. A model can have moderate computational ability but very strong memory, or vice versa. Different applications can make different choices.

If memory can live outside the GPU, then models can get bigger without GPU costs rising proportionally. Regular memory becomes useful for AI. The "memory wall" problem of GPU scaling becomes less severe. DeepSeek's upcoming V4 model is expected to integrate Engram, and we may see these benefits demonstrated at larger scale.

Engram also suggests that the current monolithic Transformer architecture might not be optimal. Different types of knowledge, fixed and flexible, are suited to different storage and processing methods. This raises new questions: what other types of specialized memory might help? Could memories related to past conversations be stored separately? Could we distinguish between "knowing what" and "knowing how"? The brain has multiple different memory systems. Perhaps AI should too.

Of course, no solution is perfect. Engram has some limitations. Its improvements on reasoning and long document tasks are larger than on pure fact Q&A, which is somewhat counterintuitive. A possible explanation is that fact Q&A already works fairly well with traditional methods, while reasoning and long document processing were more constrained originally, so the freed attention resources brought greater gains. Also, the lookup conflict problem is mitigated but not fully solved. If the memory notebook gets very large, conflicts could become an issue. Additionally, Engram adds some complexity to the training process. Finally, the paper mainly tested standard benchmark tasks. More complex agent tasks (like planning, using tools, memory across conversations) haven't been fully evaluated.

Let's step back and think about what Engram teaches us.

This breakthrough didn't come from making computation faster or training on more data. It came from asking a different question: what if we don't need to compute everything? Different problems need different solutions. Handling fixed memory and flexible thinking with the same mechanism is like using a hammer for both nails and screws. It works, but not well.

The best engineering, like the best strategy, comes from understanding the nature of the problem. DeepSeek carefully observed what large language models actually do, then asked: which parts need computation, and which parts just need memory? This question seems obvious in hindsight. The best questions always do.

Engram represents an important advance in large language model architecture. By separating fixed memory from flexible computation, it achieves better performance at lower hardware costs. More importantly, it opens a new design direction. Future models can allocate differently between memory and computation based on specific uses. The approach of "stuffing everything into parameters" may give way to more specialized, more efficient architectures.

Our understanding of how to build intelligent systems is still in early stages. Engram shows that borrowing from how the brain works, designing different storage systems for different types of knowledge, may continue to bring new breakthroughs to artificial intelligence.

The principle is simple: not everything needs to be computed. Some things just need to be remembered.

---

Original paper: Engram: Conditional Memory via Scalable Lookup

The Engram paper, "Conditional Memory via Scalable Lookup: A New Axis of Sparsity for Large Language Models," was released by DeepSeek and Peking University researchers in January 2026. The code and memory module implementation have been open-sourced.