The AI tools you use every day — Claude, ChatGPT, Gemini — are, in a meaningful sense, frozen in time. They learned everything they know during a multi-month training run, and then the learning stopped. New research published in 2025 and 2026 is attacking this problem from five different angles simultaneously. Here’s what’s actually working, what definitively isn’t, and what it means for the AI you’ll be using a few years from now.

Why Your AI Can’t Learn New Things

When you use Claude or ChatGPT, you’re talking to a model that went through a single enormous training run — consuming hundreds of billions of tokens of text over weeks or months — and then got locked. That frozen state is called its weights: billions of numerical parameters that encode everything the model “knows.”

After training, the model gets some additional tuning (teaching it to be helpful, honest, and safe), and then it’s deployed. From that point on, it doesn’t learn. Not from your conversations. Not from the news. Not from the papers published last week. The context window gives it temporary memory during a single session, but when you close that session, nothing persists. Nothing changes in the underlying model.

This is a fundamental limitation with real consequences. When ChatGPT was trained, it didn’t know about recent events, newly published research, updated medical guidelines, or the software library you just open-sourced. You can tell it these things in a message, but it won’t remember them next time, and it certainly won’t update its underlying knowledge from them.

Researchers call the technical problem “continual learning” — keeping a model learning across its deployment lifetime without destroying what it already knows. It turns out this is hard in ways that aren’t obvious. And in 2025-2026, the field has made more progress on it than in the preceding five years combined.

The Forgetting Problem (It’s Worse Than You Think)

The naive solution seems obvious: just keep training the model on new data. The problem is what researchers call catastrophic forgetting. When you fine-tune an AI on new information, it doesn’t neatly tuck that information into an unused corner. It overwrites existing knowledge.

A concrete example: take LLaMA 2 (13 billion parameters), and fine-tune it on a new domain. Measure its performance on a math reasoning benchmark called GSM8K before and after. The result, documented in the TRACE benchmark paper? It drops from 28.8% accuracy to 2%. You taught it new things, but in doing so you essentially deleted its ability to do math.

Researchers now understand why this happens at a mechanistic level — a finding from January 2026 that clarifies a lot of the previous confusion.

Understanding the mechanism changed the approach. Most of the best 2025-2026 work tries to solve the geometry problem rather than fighting it head-on.

What Researchers Are Trying

1. Build a Separate Memory Module That Learns at Runtime

The most architecturally ambitious approach comes from Google DeepMind. Their paper “Titans,” published in January 2025, proposes adding a distinct long-term memory module to the transformer architecture — one that actually updates its parameters as it reads text.

The key innovation: this memory module uses a “surprise” signal (how unexpected is this token given what came before?) to decide what’s worth remembering. High-surprise content gets written more strongly into the memory weights. Low-surprise content (things the model already knows well) barely registers. The memory module also has a built-in forgetting mechanism that functions a lot like human memory — old, rarely-accessed patterns fade.

The result is a model that can handle context windows over two million tokens long — about the length of ten novels — while maintaining accurate recall throughout. That’s not just a quantitative improvement over today’s systems; it’s a qualitative change in what AI-assisted work looks like.

2. Make Existing Architecture Weights Dynamic at Inference Time

A different approach: don’t add new components. Instead, take parts of the existing architecture that were previously static and let them update during inference.

This is the idea behind “In-Place Test-Time Training,” which won an oral presentation (the highest distinction) at ICLR 2026 — the most competitive AI research conference.

The theoretical finding buried in this paper is striking: they mathematically proved that what previous test-time training methods were optimizing for had “negligible expected effect” on making the model better at language tasks. Five years of prior work was built on a flawed objective. The right objective, it turns out, is simpler and more effective.

3. Separate “Fast Learning” from “Slow Learning”

Researchers at Databricks and UC Berkeley published what may be the most practically important paper of this period in May 2026. Their insight comes from cognitive science: humans appear to learn at two different timescales simultaneously — fast, volatile working memory and slow, stable long-term memory. Their framework applies this to LLMs.

The counterintuitive finding: RL-only training (the standard approach to improving models via reinforcement learning) makes models worse at learning new things over time. After enough RL training, the model’s weights are so far from the base model that introducing new task information causes collapse. The fast-slow framework avoids this by keeping the model anchored near its original state while letting context absorb task-specific signal.

4. Make Precise Surgical Edits to Specific Knowledge

Rather than updating a model’s general knowledge continuously, what if you could surgically change specific facts? Tell the model “The CEO of Company X is now Person Y” and have it update that specific belief without touching anything else?

This is the “model editing” or “knowledge editing” research thread, and it’s seen significant advances in 2025-2026.

The UltraEditBench dataset they published alongside this paper contains over two million editing pairs — ten times larger than any prior benchmark. The field went from “can we edit a model at all” to “can we do it two million times in a row” in about three years.

5. Design Architecture So Different Knowledge Can’t Overwrite Each Other

The most fundamental approach: fix the write geometry problem at the architectural level, so continual learning becomes structurally impossible to mess up.

That last result is the surprising one. Not only does the approach prevent forgetting — it actually produces forward transfer: training on Python made the model better at JavaScript, a related but distinct language, without ever seeing JavaScript. The shared structure in the subspaces carries useful signal across domains.

The paper also documents a vivid failure mode of standard fine-tuning: after training on Python code, a standard model starts inserting Python syntax into prose text mid-sentence. TFGN never does this.

6. Teach the Model to Be Its Own Teacher

All five approaches above either change the architecture or change how weights are updated at inference time. MIT’s Shenfeld et al. took a different angle: change how learning itself works, using a trick hiding in plain sight inside every capable language model.

The insight: large models already know how to use demonstrations in context. If you show Claude an example of how to solve a chemistry problem and then ask it a new chemistry question, it implicitly adapts its output style and reasoning to match the demonstration — that’s in-context learning. SDFT asks: what if we used that ability as a training signal?

The “on-policy” part is the critical ingredient — and the paper proves this cleanly by running the same teacher model in offline mode (generating training data from fixed examples rather than the student’s own outputs). Offline with the same teacher still loses to on-policy SDFT. It’s not just about having a good teacher; it’s about anchoring the update to where the student currently is.

A few results stand out as genuinely striking. When fine-tuned with answer-only supervision — no chain-of-thought traces, just final answers — standard fine-tuning causes reasoning collapse: the model’s average response length drops from 4,612 tokens to 3,273 and accuracy falls from 31% to 23%. SDFT under the same conditions preserves reasoning depth (4,180 tokens) and reaches 43.7% accuracy. The demonstration-conditioned teacher carries reasoning patterns implicitly, even when the supervision signal doesn’t.

There’s also a hard limitation worth naming: the method requires strong in-context learning ability to work. At 3 billion parameters it actually underperforms standard fine-tuning — the teacher is too weak. The method only becomes reliably better at 7B+, and the gains widen at 14B. This makes it a technique for frontier-scale models, not a universal solution.

The Negative Results (These Matter)

The most useful findings in this literature aren’t the wins. They’re the papers that definitively closed doors that everyone thought were open.

The Memory Problem: Building Notes Doesn’t Work As Well As Keeping Notes

One popular approach to giving AI “persistent memory” is to have the model distill its experiences into a textual memory bank that it updates over time. Systems like MemGPT/Letta do this: after each session, the AI rewrites its memory notes to incorporate what it learned. Intuitively this seems right — isn’t this what humans do?

A May 2026 paper ran the experiment rigorously and found something troubling. Memory quality follows an arc: it rises at first as the model accumulates experience, then degrades, eventually falling below the no-memory baseline entirely.

The implication: LLMs are not good at compressing their own experience into reusable lessons. The compression step introduces errors that compound over time. The better approach, at least for now, may be keeping raw episode logs and retrieving them verbatim rather than distilling them.

Even the Best Models Fail at Tracking Changing Facts

A March 2026 benchmark paper called OAKS tested 14 leading models on a deceptively simple task: read a long document where facts change over time, and answer questions correctly about the current state of those facts.

Imagine a document that says “Alice is the CEO” at page 1, then “Bob replaced Alice as CEO” at page 50, then “Carol replaced Bob” at page 120. At the end, who is the CEO? This requires not just reading comprehension but active state-tracking — updating internal beliefs as facts evolve.

The last two numbers are particularly revealing. Models could detect that a change occurred about 38% of the time. But 32% of the time they also “updated” on text that didn’t represent any change at all — confusing mention of an old fact for an update. Change detection and correct updating are essentially independent problems, and models are failing at both.

Enabling “thinking mode” (chain-of-thought reasoning) barely helped with the core state-tracking problem — it improved multi-hop reasoning but not the fundamental issue of keeping up with changing facts. RAG retrieval made things no better, and the agentic memory systems (HippoRAG, MemAgent) actually underperformed naive approaches.

Self-Improving Agents Keep Breaking Their Old Abilities

A related paper studied what happens when AI agents are allowed to continuously improve themselves — updating their own workflows, skills, and memory based on experience. The finding: all four types of self-improvement degrade previous capabilities. Agents get better at new tasks but worse at old ones in a consistent, non-monotonic pattern.

The most destructive form of self-improvement turned out to be workflow evolution — agents adding steps to their own execution procedures. Unconstrained, this produces bloated workflows that collapse under their own complexity. The paper proposes a stabilization framework (CPE) that constrains adaptation to prevent this drift, and importantly shows that the constraint improves both retention and new-task performance — the stability-plasticity tradeoff isn’t always a tradeoff.

What This Means for the AI You’re Using

If you’re a power user of Claude, ChatGPT, or similar tools, here’s the practical read on where things are and where they’re going.

The immediate practical implication: the current generation of “memory” features in AI products — where a system summarizes your preferences and injects them into future conversations — is built on a foundation that the research literature is now questioning. LLM-written memory notes degrade over time. Verbatim retrieval may be better.

The medium-term implication is more interesting. The fast-slow learning framework from Databricks/UCB (treat optimized prompts as “fast weights,” model parameters as “slow weights”) provides a roadmap for systems that adapt usefully to individual users and domains without the catastrophic forgetting problem. The key insight — that task-specific knowledge should be absorbed by context, not parameters — is architecturally clean and practically deployable. Expect to see it in production systems within 12-18 months.

The Titans architecture (neural long-term memory that updates at inference time) points toward something more fundamental: blurring the line between training and inference. If a model can run small gradient updates on its memory module while simply reading your input, the distinction between “training” and “using” starts to dissolve. This is architecturally promising but has a real safety question: an AI whose weights change during inference is harder to align and audit than one that stays static.

The Architecture of Memory That’s Emerging

Step back and look at all the successful approaches together. A pattern emerges that maps surprisingly well to how human memory actually works:

The research suggests that trying to collapse all these into a single mechanism — as most current AI products do — is a mistake. The fact that your notes-app AI tries to summarize your preferences into a paragraph and feed it back to you next session conflates episodic and semantic memory in a way that produces mediocre results at both.

The systems that will work — the ones the research is clearly pointing toward — will maintain raw episode logs for faithful recall, use fast prompt optimization for task adaptation, and reserve parameter updates for slow periodic consolidation of genuinely durable knowledge. It’s a more complex plumbing job, but the cognitive science suggests it’s the right architecture.

What to Watch For

The “frozen AI” problem has a clear solution path now. That’s new. A year ago, the field had many competing approaches and no consensus on which geometry of the problem was even tractable. The 2025-2026 literature converges on a few ideas that are robust:

• Separate fast and slow learning. Task-specific knowledge shouldn’t be baked into parameters — it should live in context or lightweight fast weights that can be updated and discarded without corrupting the underlying model.
• Keep raw episodes, don’t compress them. LLMs are bad at summarizing their own experience in ways that preserve fidelity. The instinct to “clean up” memory notes actually destroys information.
• Track changing facts explicitly. Current models fail badly at state-tracking across long documents. This is a solvable problem but nobody has solved it yet — the OAKS benchmark results are damning across the board.
• Surgical edits are now reliable at scale. For cases where you need to update a specific fact (a product name changed, a guideline was revised), model editing approaches like UltraEdit are ready for production.

The timeline for users experiencing these changes: the fast-slow framework and better episodic memory management could show up in products within a year. Architectural changes like Titans require new training runs from scratch and are at least 18-24 months from anything most people will use. The streaming knowledge-tracking problem — making an AI that genuinely keeps up with the world — is probably three to five years out.

But the direction is clear. The frozen AI isn’t a permanent condition. It’s an engineering problem with a research solution that’s now far enough along to have a plausible timeline.