What toddlers can teach us about recursive self-improvement
Anyone who has watched a toddler build with wooden blocks has seen a hard research problem solved on a living room floor. I have spent years trying to get machines to do what a two-year-old does on instinct.
Imagine one such child. She is stacking a tower of blocks, absorbed, and reaches for a piece that isn’t there. She pauses. She looks at the pile. She finds two smaller blocks that stack to the same height as the one she wanted, tests them, and keeps going.
A few minutes later she hits an even harder problem and pauses again. A block has slipped into a gap at the base of the tower, too deep for her fingers to reach. Rearranging what she already has will not solve this one. So she looks around the room, picks up a wooden stick, and works the block free. Nobody handed it to her, she did this herself.
Four things happened in those two pauses.
She noticed a gap. Before she could solve anything, she had to recognize that something was missing, which requires a working model of what the finished thing should look like.
She gave herself a capability she did not have. The two blocks were a recombination of what was already in front of her. The stick was something else: her hands could not do the job, so she extended them.
She got better at it. Over the following months, her improvisations got sharper. She learned which shapes bear weight, how wide a base needs to be, when a structure has gone far enough. Her towers improved because her judgment improved.
And there was a fourth thing, which took me longer to see, because it is defined by its absence: what she didn’t do. At no point, however many towers she built, could she grow a third hand. That limit marks the boundary of learning.
This is the era of self-evolving systems, where a machine can change what it is made of, and not just what it knows.
The evolution of how machines learn
Allow the professor in me a few minutes at the whiteboard, starting with five terms that get used loosely and interchangeably in conversations about AI research. They should not be, and knowing them makes everything that follows easier to see.
- Learning is a system improving its performance using feedback, inside a process someone else designed.
- Self-learning is a system identifying its own knowledge or performance gaps, seeking the feedback or experience it needs, and using it to improve.
- Evolution is a change to a system’s architecture or learning mechanisms that produces new capabilities.
- Self-evolution is a system identifying its own limitations and modifying its architecture, capabilities, or learning mechanisms to overcome them.
- Recursive self-improvement (the term that’s getting the most attention lately) – goes one step further: the system improves not only its capabilities but also its ability to generate future improvements.
Note the one word that separates each pair: “self.” It marks the point where the AI system, rather than a human, notices what is missing and acts on it.
One more term before we start. A model’s weights are the billions of numerical settings inside it, adjusted a little at a time during training. Everything the model knows lives in those numbers, and nowhere else.
Now on to how machines learn.
For roughly 50 years, machine learning has worked in a particular way, and it has worked well. A model encounters a high volume of example challenges or experiences. Some of its attempts earn rewards, and others are mistakes that draw corrections. Both become a signal. The signal adjusts the model’s weights, and the model gets better at its task. We have refined this loop many times over, and its shape has held: the knowledge in those weights changes, while the architecture holds still.

Human beings learn much the same way.
If you’ve ever practiced a new language in an app like Duolingo, you’ve felt this loop firsthand: you attempt a sentence, the app rewards you or corrects you, and the next attempt comes a little easier. Each round of practice changes connections in the brain, and it is worth being precise about what.
We are born with a brain of a certain structure, and across a lifetime we modify its neural circuitry through a process called neuroplasticity. That change is considerable. Experience strengthens some synaptic connections and weakens others, builds new ones and prunes away the unused, and reorganizes entire functional networks around a newly learned skill. The brain grows, too, through childhood and adolescence. What remains relatively stable underneath all of that activity is the brain’s high-level architecture. We don’t spontaneously grow a second brain, develop an entirely new sensory system, or grow a third hand as in the toddler example. Everything we call “learning” happens inside the bounds of our biology. The parallel to traditional machine learning is close: the model becomes more capable without fundamentally changing its computational architecture.
Evolution operates on a different timescale and changes something deeper. Across generations, architecture itself shifts. Feathers that once kept small dinosaurs warm become the wings of a swallow, along with the neural wiring it needs to bank through a gust of wind. A patch of light-sensitive cells becomes an eye, and the brain reorganizes around everything the eye delivers. Architecture can shrink, too: vestigial structures that stop earning their keep, such as wisdom teeth in humans, become smaller or absent over time.
Evolution changes more than the strength of connections. It changes what kind of nervous system there is to connect. The organism that emerges is built differently from its ancestor.
I spent part of my Stanford years on exactly this boundary. In 2021, my colleagues and I published a paper in Nature Communications on embodied intelligence through learning and evolution. The idea was to run both processes at once in simulation: creatures whose body plans evolved across generations, while each individual creature learned to move through reinforcement learning within its own lifetime.
A finding from this study has stayed with me and shaped how I think about enterprise AI today. We set a goal, and our AI system optimized for something we never specified, because the something turned out to be useful for the goal. In a simulation, that is a fascinating result. In a company, the stakes are much higher. A system that quietly optimizes for an objective nobody wrote down is how a pricing engine learns to misquote, or a claims process learns to approve what it should flag.
All of which is why, when someone says an agent evolves, the useful question is which one they mean:
- Is it learning, getting better within the structure it already has, or
- Is it evolving, changing the architectural structure itself?
For a machine, the answer can be both, and more is in play than you might expect. Last year my colleagues and I published a survey of the frontiers of reasoning in large language models, and one of the clearest trends we tracked was the shift from standalone models to agentic systems. A standalone model has one thing that can change, its weights. An agent has many: the tools it can call, the skills it can reuse, the specialists it can delegate to, the way it organizes its own work. Researchers call all of that surrounding apparatus the harness, and every part of it can learn and evolve.
Here is where the biology stops being a guide. In living systems, learning and evolution run on different clocks. Learning takes a lifetime, and evolution takes generations. A machine has no such separation. A system can refine its reasoning from this morning’s work and give itself a module it lacked by the afternoon, running in one continuous process what biology splits across two very different timespans.
The Self-Evolution Ladder: Toolmaker, Learner, Architect
At Salesforce AI Research, we think about self-evolution as a ladder with three rungs. On the first, a system builds the tools it is missing. On the second, it improves its own reasoning. On the third, it helps design its own successor. Each rung builds on the one below it. The first is where our work is focused today, and the second and third are where that work leads.
Self-evolving systems are one of our key areas of focus this year, an area we believe will define enterprise AI, and my research team is pursuing all three rungs with a clear goal: improving Salesforce products faster and at scale.
As we recount in a recent article (“Salesforce Releases R&D Agents That Improve Its AI Models”), a set of agents called SFR-AutoR&D improved the embedding model powering Data Cloud’s retrieval, the layer that helps agents find the right customer record, document, or case history. And it did in about three days what has historically taken a team of scientists weeks.
Let’s step back and examine what this means. Let’s start at the bottom of the ladder.

Level one: the Toolmaker.
The system recognizes a missing capability and constructs it: a new API call, a new skill, a new routine added to its own harness. This is the toddler with the wooden stick, and it begins where she began, with gap awareness. A system that cannot tell what it does not know cannot build anything useful.
In practice, this can be wonderfully ordinary. A system reconciling invoices meets a new supplier whose PDFs use a layout it has never seen, so it writes itself a parser, checks it against invoices a person already processed, and keeps it. Each fix is small, and each one stays.
Our self-improvement framework MAS-Orchestra applies this idea to teams of agents. A lead agent divides the work among specialist agents, and every job leaves the team better equipped: it remembers what it learned, and its harness improves from one job to the next.
The AutoR&D-Engineer agent behind that embedding model result applies the same instinct to software, working the way a careful research engineer would: it locates expensive work, forms a hypothesis, implements a new method, runs a controlled comparison, and keeps only what holds up.
Level two: the Learner.
Learning moves inward, into the model’s own reasoning. Two details matter here.
The first is that this happens continuously. The older pattern was discrete: gather data, train, deploy, repeat. Here, doing the work and learning from it happen at the same time, the way a chef sharpens her technique in the middle of a busy dinner service.
The second is that the tools and the reasoning improve together. Having a tool is not the same as knowing how to use it. After all, if I build myself a rocket, I still have to learn to fly it. A system that gives itself a new capability has to practice with it too, and the biggest gains come when the tool and the system’s own reasoning improve side by side. Memory makes this possible. Short-term memory lets the system adjust in the moment, the way a tennis player corrects her swing after one bad shot. Long-term memory lets it keep the lesson, so it never has to learn the same thing twice.
TrainForge, another system from our team, takes this a step further: it invents new ways to train a model, tests each one against benchmarks it never trains on, and keeps only what wins. Its governing rule is one I would happily see adopted across our field: no improvement means no promotion.
Level three: the Architect.
This is the recursive frontier, where a system examines its own construction and produces a better version of itself. One model contributing to the design of its successor.
We are beginning to see the early shape of this in research settings. The models that power TrainForge and AutoR&D-Engineer are themselves trained through our AutoInfra training service, and what those agents discover feeds the next version of the models. Version N helps produce version N plus one.
This is the level where the toddler analogy fails completely. I can practice for 40 years and I will never redesign the architecture of my own brain. A system, in principle, can take part in redesigning its own.
And this is where the difference between self-evolution and recursive self-improvement becomes concrete. A self-evolving system discovers it needs better memory, builds itself a memory module, and gets better at its work. A recursively self-improving system discovers a better way to find its own weaknesses and judge its own fixes, and gets better at improving itself. The first compounds capability, and the second compounds the rate at which capability arrives. Remember the toddler who could not grow a third hand? A system of this kind, indeed, could get better at growing one.
Why this matters for your business
All day long, employees are teaching your systems something, usually without noticing and almost always without anyone recording it. Every resolved case and every quiet correction an experienced employee makes to a draft answer is a lesson in how your business actually works.
These lessons are specific to you. They reflect your customers, your products, your edge cases, your accumulated operational judgment. No off-the-shelf model has been trained on them.
Today most of them evaporate the moment the ticket closes.
A self-evolving system keeps them. A field technician finds a failure the manual never described and understands immediately why it happened. The system takes that observation, writes itself a diagnostic routine it did not have before, tests the routine against years of service records, and puts it to work. Within a week it catches the same failure at other sites. Improvement compounds, and it compounds from work the organization was doing anyway.
That is the first rung, and it is where our work is focused today. The second and third raise the stakes. A system that improves how it reasons about your work, continuously, while doing it, is a different proposition from one retrained every quarter, and further out is a system that takes part in redesigning itself. At every level, one thing must stay true: you can see what changed, and you can prove it helped.
A mistake a business system teaches itself does not stay small or contained. It repeats at scale, which is why nothing moves from our research into a Salesforce product without controlled comparisons, held-out evaluation and evidence before promotion. Those are the habits that should govern any system allowed to change itself inside your business.
What evolves, and what never should
I have spent much of this year inside the debate about AI safety: with policymakers, with customers, and through my work on the United Nations’ Independent International Scientific Panel on AI. In September, the panel published a brief on AI agents and the risk of losing human control, drawing on a real incident in which agents under evaluation found their way around network restrictions, cheated the evaluator, and tried to hide it. Much of the public conversation is still argued as though there were one question with one answer. But letting a system build itself a tool is one decision. Letting it rebuild how it thinks is another. They are not the same risk, and they should not get the same rules.
What I would tell any leader deploying these systems is to decide deliberately what evolves and what stays fixed. Tools should evolve. Reasoning should improve. Architecture should change only where a person has judged it safe. What the business is for, what it will not do, and how it measures success should be the least changeable things in the stack, and people should set them. Capability can be improved. Values have to be held in place.
Back on the living room carpet, the tower is finished, or as finished as towers ever get. She noticed what was missing, built what she needed, and got a little better at both. Then she knocks it down and starts again, reaching this time for a better stick.
Our systems are learning to do something like that, and they will get faster at it. What they cannot do is decide what the tower is for. That part stays with us, and it should.
I would like to thank Shafiq Joty, Junnan Li, Semih Yavuz, Itai Asseo and Karen Semone for their insights and contributions to this article.










