About this video
An AI agent learned to ask before acting: 61% of the time instead of 5%. One edit to its own instructions later, it asked 8.5% of the time, and its score on those tasks fell 10 points.
What rule would your agent overwrite first?
We read the new Google DeepMind + Mila preprint "Are Self-Evolving Agents Continual Learners?" page by page: what continual learning and catastrophic forgetting are; how self-evolving agents improve by rewriting their harness (prompt, memory, skills, code) instead of their weights; the three methods tested (ReasoningBank, GEPA, Meta-Harness) on four streams of changing work built from BIRD, BFCL and ScienceWorld; why the gains were small; why learning faster meant forgetting more (r = -0.72); three ways one shared prompt breaks (lessons leak forward, old lessons get squeezed out, a habit flips into its opposite); memory's blind spot (52% of ask-first tasks pulled an act-now card); what the paper does not show; and five things to do about it if you build AI agents.
Chapters
0:00 The agent that forgot how to ask
1:01 Learning without forgetting
2:53 Finding 1: It helps, a little
3:29 Finding 2: Learn faster, forget more
4:36 Finding 3: One shared prompt, three ways to break
7:06 Finding 4: Memory has a blind spot
8:26 What this paper does not show
9:19 What to do about it
10:35 Recap
Paper: Are Self-Evolving Agents Continual Learners? Xiaoyin Chen, Yizheng Huang, Yinglun Xu, Ziyun Zhao, Emmett McQuinn, Julie Liu, Hope Yao (Mila - Quebec AI Institute, Université de Montréal, Google DeepMind). arXiv:2610.25858, October 2026 (preprint, not yet peer reviewed). https://arxiv.org/abs/2610.25858
Figures, tables and excerpts from the paper are shown under its CC BY 4.0 licence (https://creativecommons.org/licenses/by/4.0/) with credit; the highlights, redrawn bars, animations and characters are ours.
Music: Voice Over Under by Kevin MacLeod, CC BY 3.0, via Wikimedia Commons (https://commons.wikimedia.org/wiki/File:Voice_Over_Under_(ISRC_USUAN1600001).mp3)
Pranav Innovates: AI research, explained. Subscribe to stay up to date.
YouTube: https://www.youtube.com/@PranavInnovates
Instagram: https://www.instagram.com/pranavinnovates
What the video says
An AI agent picked up a good habit on the job. When a user left out something it needed, it stopped guessing and asked. It went from asking about one time in twenty to six times in ten. Then it moved on to new tasks, where needless questions were penalised, and it rewrote its own instructions to fit. One edit later, back on the old tasks, it asked less than one time in ten, and its score fell ten points. Nobody told it to forget. This is the promise everyone is chasing right now: agents that improve themselves while they work. No retraining. They just rewrite their own prompts, memory and skills. But do they keep what they learn? A new preprint from Google DeepMind and Mila put three popular self-improving methods on work that keeps changing. The method that learned fastest also forgot the most. And the fix you'd reach for first, memory, has a blind spot of its own. Stay to the end for five ways to keep your own agents from forgetting. The paper is called Are Self-Evolving Agents Continual Learners? Let's read it, page by page. First, two ideas. Continual learning means learning new tasks as they arrive, without forgetting the old ones. Neural networks are famously bad at it. Train them on a new task, and the old one fades. That's called catastrophic forgetting. Retraining a big model after every session costs far too much. So the new trick is to leave the model alone and change its harness instead: everything wrapped around it. The system prompt, memory, skills and code. If you watched our last episode, that's the same harness an agent improved there. These are called self-evolving agents. The paper tests three of them. ReasoningBank is a librarian: after each task it writes a memory card, and before the next task it pulls out the single most similar card. GEPA is an editor: it rewrites one strategy section in the system prompt. And Meta-Harness is a renovator: it can edit the prompt, the memory and skill files, even the agent's own code, but it keeps a change only if it scores better on the current tasks. All three use the same model, Gemini 3.6 Flash, and the same starting harness. Each one faces a stream of tasks in blocks of fifty: writing database queries, calling tools for a user over several turns, and running science experiments in a text world. The agent is never told when the task changes. There are four kinds of change. The topic shifts, across three different databases. The workflow shifts: same tools, but first you must ask the user about missing details, and then you must not. The whole domain shifts. And a long stream mixes all three. After every block, they test the agent on every task type, old and new. That gives two scores. Plasticity: how much it learned on the current tasks. Stability: how much it damaged everything else, both tasks it hasn't met yet and tasks it already learned. I've grouped what they found into four findings. Finding one. Self-evolution helps, a little. Averaged over all four streams, GEPA finished three point seven percentage points above where it started. ReasoningBank, two point five. Meta-Harness, one point four. And on the topic stream, switching between databases, the gains vanished. GEPA ended one point seven below its start, Meta-Harness one point five below, and ReasoningBank just zero point three above. For builders: a self-improving agent on shifting work isn't a free upgrade. Measure the gain, because it can be small, or even negative. Finding two, the heart of the paper. Learning faster means forgetting more. GEPA learned the most. Within each block it gained six point two points on average, and eleven on the workflow stream. It also did the most damage everywhere else: a stability score of minus four point three on average. ReasoningBank was the most stable, at minus one point nine, but it learned only about half as much. And Meta-Harness? It looked stable on two streams, but only because its gate rejected half or more of its proposed edits. Its harness simply froze. Take the gate away, and its stability fell to minus three point one and minus five point five. So can any of them learn fast and keep everything? Take a guess. No. Plot all twelve pairs of method and stream, learning against stability, and they slope downhill: a correlation of minus zero point seven two. No method scored high on both. For builders: if your agent rewrites itself and you only measure today's tasks, you'll only see the learning. The forgetting happens off camera. Finding three. Why do GEPA and Meta-Harness forget? Because every lesson goes into one shared prompt or workspace, and every future task reads it. Break one: lessons leak forward. After two blocks of database queries, both methods had written rules like: inspect the schema first, test every query interactively. Then it was tested on tool tasks where the right move is to ask the user. The agent went exploring instead. GEPA fell six point eight points below its start, before it had seen a single one of those tasks. Break two: old lessons get squeezed out. Right after its block, the first database's rules filled all of GEPA's strategy. Two blocks later they were down to forty percent, and that database's score fell from seven and a half points above the start to two below. In another stream, GEPA squashed seven database sections, about three thousand four hundred characters, into one section of about a thousand, and a four point gain was gone by the end. Break three is the opening story. Same tools, but first the agent must ask about missing details, then it must not. Before training, it asked on only about four to six percent of those tasks. After the asking block, it asked far more often. Then came the block that penalises needless questions. What happens to the old habit? Take a guess. It flips. In the long mixed stream, Meta-Harness had written a rule into its prompt, its memory and its skill files: don't call tools while arguments are missing. One accepted edit later, all three files said: run the tools immediately. Asking fell from sixty point eight percent to eight and a half, and its score on the old tasks dropped ten points. On the workflow stream, GEPA flipped the same way and lost thirteen. Once, it went well. When the domains were completely different, GEPA kept all six science sections word for word and simply added new ones. No forgetting. But it did that on its own, not by design, and it didn't happen reliably. In another stream, it compressed instead. And shuffling the tasks didn't save it. With all four task types mixed from the start, GEPA's final gain shrank from five point eight to zero point nine, because the task types kept fighting over the same prompt. For builders: one global prompt that absorbs every lesson is a shared whiteboard that everyone keeps erasing. Keep task-specific rules where only that task can see them. Finding four. So why not use memory instead? ReasoningBank never rewrites the prompt. It stores cards and pulls out the most similar one. Across very different domains, that works. Science experiments, tool calls and database questions sound nothing alike, so a card from the right task always came back, and forgetting was zero. But it always pulls a card, even when none fit. Before each task type's own block, every single episode got a card from a different task. Tool tasks got database tips, and dropped up to three point two points. Worse is a collision. The ask-first tasks and the act-now tasks use the same tools and sound the same. How similar the two groups are to each other, about zero point eight four, is the same as how similar each group is to itself. No threshold can tell them apart. So by the end, fifty two percent of ask-first tasks pulled a card that said act now. Their gain fell from twelve and a half points to four and a half. The authors put it like this: semantic similarity between queries captures topical overlap, but cannot determine whether a stored trajectory's workflow is compatible with the incoming task. In plain words, it knows what a task is about, not how to do it. For builders: label each memory with the kind of task it came from, not just its words. Now, what this paper does not show. It used one model, Gemini 3.6 Flash. Three methods. Three benchmarks, in blocks of fifty tasks, tested on fifty held-out tasks per group, ninety for the science world. Most effects are a few percentage points. The paper reports no error bars across repeated runs, and the main correlation rests on twelve points. And it's a preprint, not yet peer reviewed. By design, the agent was never told that the task had changed. Real products often know what kind of task they're serving, and could use that. It also tests three methods, not all of them. Harness squared, from our last episode, wasn't one. The authors' conclusion: today's self-evolving agents are incomplete continual learners. What's missing is a way to keep task-specific updates apart, and to choose memories by more than surface similarity. So, what do you do if you build agents that improve themselves? Five things. The first four follow from the paper's findings. The last one is my take. One. Scope your lessons. Put task-specific rules in a section, skill or file that loads only for that kind of task, not in the prompt every task reads. Two. Re-test old tasks after every self-edit. Meta-Harness checked each change only on the current tasks, and still forgot. Keep a small test set for every task type, and reject any edit that breaks one. Three. If you retrieve memories, a similarity threshold helps when nothing fits, but it can't fix a collision. So also store the kind of task and its workflow with every card, so an ask-first task never gets an act-now card. Four. Watch for opposite rules. When two tasks share tools but need opposite behaviour, write both rules down, each with when it applies. Otherwise, the newest one quietly wins. Five, my take. Last episode, Harness squared started every new task from the plain harness and treated old lessons as guesses until the evidence confirmed them. This paper didn't test it, so it's my bet, not a result. But after reading this, that looks less like caution and more like the point. Let's recap. Self-evolving agents improve by rewriting their harness, not their weights. On work that keeps changing, they gained a little. The faster they learned, the more they forgot. A shared prompt leaked lessons forward, squeezed old ones out, and even flipped a habit into its opposite. And memory pulled the wrong card when two tasks sounded alike. The model never changed. Its notes did. Remember the agent that learned to ask, then stopped? It didn't lose any intelligence. It lost one rule, overwritten by a newer one. So if your agent rewrites itself, keep yesterday's tests running. Getting better at today's work is easy. Staying good at yesterday's is the hard part.