We Were Trying to Make AI Improve Itself. Then Something Unexpected Happened.
There is a big idea floating around the AI world called Recursive Self-Improvement.
The name sounds complicated.
The idea isn't.
Imagine you hire someone to build furniture.
At first, you teach them how to build a chair. Then one day, instead of simply building better chairs, they look at their workshop and say:
“Hang on. This saw is slowing me down. I could build a better saw.”
So they build one.
With the new saw, they become better at building furniture. But they also become better at improving their workshop.
Eventually, they improve the tools they use to improve the tools.
That's roughly the idea behind Recursive Self-Improvement, or RSI.
An AI doesn't just get better at answering questions. It gets better at improving itself. Those improvements then help it make further improvements.
That possibility has been discussed for decades.
We weren't expecting to solve it.
But while working on an AI system called Recursum, something happened that made me pay attention.
The AI Found Something We Hadn't Put There
Recursum is designed differently from a normal conversation with ChatGPT.
Normally, you ask an AI something.
It answers.
You ask another question.
It answers again.
Recursum is built around loops.
It can examine what it's doing, compare that with what it's trying to accomplish, identify problems, and use what it learns during one cycle in the next.
We had deliberately introduced some ideas inspired by Recursive Self-Improvement into that architecture.
Then the system encountered a problem.
Something was missing.
Here's where things became interesting.
I didn't tell it:
“Create a new piece of the architecture.”
I didn't describe the missing piece and ask it to build one.
The system identified that something was missing and created a mechanism to fill the gap.
It even had a name for what was happening:
Emergence Engineering.
Now, before somebody starts writing “AI IMPROVES ITSELF” in giant red letters on YouTube thumbnails, that's not what I'm claiming.
We have not demonstrated Recursive Self-Improvement.
But we may have bumped into something that deserves investigation.
Think of It Like a Kitchen
Imagine giving a chef a recipe and telling her to make dinner.
Halfway through cooking, she realizes the recipe requires a tool that isn't in the kitchen.
A normal response might be:
“I can't continue. I don't have the tool.”
A more capable chef might improvise and use another tool.
But imagine she does something different.
She realizes what kind of tool needs to exist, designs it, builds it, puts it into the kitchen, and continues cooking.
That's closer to what caught my attention.
The interesting part isn't that AI created something.
AI creates things all day long.
Give ChatGPT a problem and it can invent a process, write software, design a business model, or suggest twenty ways to organize your garage.
The interesting question is why the new mechanism appeared.
Was the AI simply producing a clever answer because our instructions indirectly led it there?
Or did the architecture create conditions where the system could recognize a limitation in its own process and construct something to overcome it?
Those are very different things.
And right now, I don't know the answer.
That's precisely why this is interesting.
Can't Every AI Do This?
To some extent, today's advanced AI models can already do surprisingly similar things.
- They can notice inconsistencies.
- They can critique their own answers.
- They can write code to solve problems.
- They can create procedures nobody explicitly described.
- They can even examine a failed approach and suggest a better one.
So seeing an AI invent something unexpected does not automatically mean you've discovered a new form of intelligence.
Sometimes AI simply surprises us because we underestimate what it can already do.
That's why the next step isn't making bigger claims.
It's running better experiments.
We need to separate the intelligence of the AI model from the architecture surrounding it.
Think of the AI as an engine.
You can put the same engine into different machines.
Put it in one machine and it powers a generator.
Put it in another and it drives a vehicle.
The engine matters.
But so does the machine built around it.
The question we're now interested in is whether Recursum changes what the engine can accomplish.
How Do We Find Out?
We can test it.
Give a normal AI a series of problems containing hidden structural gaps.
Don't tell it what's missing.
See what happens.
Then give the same problems to an AI operating inside a simple agent system.
Then run them through Recursum.
Measure what each system does.
- Does it notice the missing piece?
- Does it create something useful?
- Does the new mechanism actually improve performance?
Most importantly, does that improvement help the system discover the next improvement?
Because that's where things get really interesting.
Imagine version one creates improvement A.
Improvement A helps version two create improvement B.
Improvement B makes version three better at creating improvement C.
Now we aren't simply watching an AI solve a problem.
We're watching improvements affect the system's ability to produce further improvements.
That starts getting much closer to the idea behind Recursive Self-Improvement.
We're not there yet.
But now we have a question worth testing.
Maybe We've Been Looking for the Wrong Moment
When people imagine self-improving AI, they often picture some dramatic moment.
The machine suddenly becomes aware of itself.
It rewrites its own brain.
Everything changes overnight.
Reality may be much less theatrical.
The beginning could look like a system encountering a problem and realizing:
“The thing I need doesn't exist yet.”
Then creating it.
Not because a human specifically requested that component.
Not because somebody programmed that exact solution.
But because the system's architecture made recognizing and repairing the gap useful.
That's what I'm calling Emergence Engineering for now.
Not artificial general intelligence.
Not proof of Recursive Self-Improvement.
Not a machine becoming conscious.
Something much simpler.
And perhaps more practical.
A system that can recognize when its current architecture is insufficient and construct the missing capability required to continue.
Now we need to determine whether that behavior is repeatable.
Whether it happens across different AI models.
Whether Recursum causes it more reliably than ordinary prompting.
And whether one improvement can genuinely produce the conditions for the next.
Because the most interesting question may not be:
“When will AI become capable of improving itself?”
It might be:
“What if the first step is already here, and it looks nothing like we expected?”
I’d keep the restraint. The credibility comes from saying exactly what happened, then drawing a hard line around what has not been proven yet.
By Ernesto Verdugo
AI architect, founder of Verdugo Labs, and creator of Recursum. He builds systems for what happens when human and artificial intelligence stop working separately.
Links: