Research direction. This essay examines a research question about how an AI system might turn experience into reliable long-term improvement. It does not claim that AdamI currently has a completed continuous-learning system, autonomous self-modification, or AGI.
Today’s AI can work longer than ever. But working longer is not the same as learning from experience.
There’s something strange about the direction AI agents are heading.
We are getting better at making them work for longer.
An agent can spend hours navigating a codebase, researching a problem, calling tools, fixing errors, and trying again. We’re beginning to build systems that can keep tasks alive in the background, resume after interruptions, and pick up work that would previously have required a human to restart the whole process.
That’s real progress.
But I’ve been thinking about what happens after all those hours of work.
Suppose an agent spends an entire afternoon debugging a difficult problem. It tries several approaches, makes a few mistakes, eventually finds the real cause, and produces a working solution.
The task is complete.
A week later, the agent encounters a similar problem in another project.
How much of what happened last week has actually made it better at solving this one?
It might retrieve the previous conversation. It might find a saved note or a summary of the solution. With the right context, it could use that information quite effectively.
But what if nobody thought to save the important lesson? What if the two problems look different on the surface? What if the previous solution worked for reasons the agent never correctly understood?
And what if the system remembers the wrong lesson?
This is the part that interests me.
We’re learning how to give AI agents longer working lives. We’re still figuring out how to give those lives a meaningful learning process.
A long-running agent can still have a mostly static brain
Most of the progress we see in AI agents today happens during inference.
We give a model a problem, some context, access to tools, and enough time or computation to work through the task.
It can reason, search, experiment, and revise its approach.
Sometimes the results are extraordinary.
But there is an important distinction between getting better during a task and becoming better because of the task.
A model can adapt to information inside its current context. An agent can also use external memory, saved instructions, tools, or updated workflows to carry useful information into future tasks.
Those mechanisms matter. They already make today’s systems more useful.
Yet they don’t automatically create a reliable process of cumulative learning.
The underlying model may remain unchanged. A saved memory may never be retrieved. A useful observation may stay buried in a log. A local workaround may be reused in situations where it no longer applies.
In other words, the system can accumulate history without consistently improving from it.
That’s a strange kind of persistence.
Imagine an engineer who works on hundreds of projects, remembers many of the conversations, and can search through everything they’ve written, but whose working habits never reliably improve.
They might become extremely knowledgeable about their past.
That doesn’t necessarily mean they’ve become better at their job.
I think something similar can happen with agents.
We can build a system that runs continuously, stores everything, and still approaches many recurring problems as though it were encountering them for the first time.
Persistent execution is becoming practical. Persistent learning remains a much harder problem.
And I suspect the gap between the two is going to become increasingly visible.
Memory is useful. Learning asks a different question.
While building AdamI, I’ve spent a fair amount of time thinking about memory, task continuity, and the relationship between past experience and future behavior.
One lesson keeps coming back: storing an experience is not the same as knowing what to do with it.
But the learning problem goes further than that.
Memory asks what happened before.
Learning asks what should change because it happened.
That sounds like a small difference. I don’t think it is.
Suppose an agent calls an API and gets an error.
Should it remember the error? Probably.
Should it change its future behavior? Maybe.
Should it permanently avoid that API? Almost certainly not based on one failure.
The error could have come from a temporary outage, an expired credential, bad input, a network issue, or a genuine limitation in the tool.
The experience itself doesn’t tell us which lesson is correct.
Now imagine the agent succeeds.
The same problem appears in reverse.
Did the strategy work because it was generally effective? Was the result mostly luck? Did the environment happen to be unusually forgiving? Would the same approach work under different conditions?
Success isn’t automatically evidence that a strategy deserves to become permanent either.
This is where the idea of an agent simply “learning from its mistakes” starts to feel too vague.
We make it sound as though experience naturally turns into improvement.
In reality, experience is messy.
It’s incomplete, highly contextual, sometimes misleading, and frequently contradictory.
Before a system can learn reliably, it needs some way to distinguish a useful pattern from an accident.
And that judgment may be harder than the original task.
The problem isn’t collecting experience. It’s deciding what deserves to change.
I think there’s a temptation in agent development to imagine learning as a straightforward feedback loop.
The agent acts, observes the outcome, updates itself, and performs better next time.
It looks elegant on a diagram.
But I become less comfortable with it the longer I think about real-world tasks.
A single outcome rarely tells the full story.
An agent might receive positive feedback for a result that was correct but achieved through a risky shortcut. It might be penalized for a sound decision because an external dependency failed. It might discover an efficient strategy that works beautifully in one environment and breaks somewhere else.
If every experience can directly alter future behavior, the system risks learning the wrong things very quickly.
This is not just a problem of model weights.
An agent can change its behavior through many mechanisms: saved procedures, preferred tools, routing decisions, persistent instructions, retrieved strategies, or changes to its surrounding software.
Some of these are easier to inspect and reverse than others.
All of them can influence future decisions.
That means continuous learning is not simply about whether an AI can update its own neural network.
A system with fixed model weights could still improve through carefully evaluated external knowledge and reusable strategies.
And a system that frequently updates its weights might still fail to learn reliably.
What matters is whether experience produces a durable improvement that survives beyond the original situation.
Even then, I would want to ask another question:
Improvement according to whom, and measured against what?
An agent might become faster while becoming less careful. It might solve more tasks while quietly increasing the chance of an unauthorized action. It might optimize a benchmark while losing flexibility in unfamiliar situations.
More learning is not necessarily better learning.
What we’re really looking for is an ability to improve without losing the properties that made the system useful in the first place.
How does a system change without breaking itself?
This may be the most difficult part of the whole problem.
An intelligent system that cannot change will eventually run into the limits of what it already knows.
But a system that changes too freely can become difficult to predict or trust.
There’s a tension here that I think matters enormously for AGI:
A system needs to remain stable enough to be trusted, while staying flexible enough to learn.
People experience versions of this problem too.
We develop habits because repeating every decision from scratch would be exhausting. But habits can become outdated. We learn from mistakes, yet sometimes draw the wrong conclusions. We acquire new skills while trying not to lose old ones.
For AI, the problem has its own technical complications.
A new strategy might improve one category of tasks while making another worse.
An update might overwrite something that was previously reliable.
A temporary workaround might gradually become a default behavior.
An agent might become very good at satisfying a narrow evaluation while drifting away from the broader objective it was supposed to serve.
And when an agent has access to tools and external systems, a bad update doesn’t have to remain a bad answer.
It can become a repeated action.
That’s why I’m skeptical of treating unrestricted self-modification as the natural destination of autonomous agents.
The ability to change yourself is not automatically the ability to improve yourself.
If anything, it introduces another class of problems that the system must learn to manage.
Maybe learning needs a review process of its own
When I think about how an agent could learn over months or years, I keep coming back to an idea borrowed from ordinary engineering.
We don’t normally take every proposed code change and push it directly into production.
We inspect it. We test it. We compare it with what already works. We sometimes reject it.
And when something goes wrong, we want the ability to roll it back.
Why should changes to an agent’s long-term behavior be treated more casually?
Imagine an agent noticing that a particular strategy has worked repeatedly.
Instead of immediately making that strategy a permanent rule, it could preserve the experience as evidence and propose a change.
That change could then be evaluated against other tasks, including situations where the strategy might fail.
If the results hold up, the system could adopt it within an appropriate scope.
If the results are uncertain, it could keep the observation without promoting it into a general policy.
If the change causes problems later, it should be possible to understand what changed and reverse it.
I’m not suggesting that every small adjustment needs a human committee.
That would make the system impossibly slow.
Different kinds of learning should probably require different levels of scrutiny. Remembering a harmless preference is not the same as changing how an agent handles credentials, money, or deployment permissions.
But the underlying principle seems important.
An experience should be allowed to suggest a change without automatically authorizing that change.
That would let the system remain adaptable without treating every new observation as a reason to rewrite its own behavior.
Of course, designing such a process is much easier than proving it works.
How do we evaluate improvements across a large and changing set of tasks? How do we detect gradual deterioration? How do we avoid building an elaborate review process that blocks useful learning?
Those are open engineering questions.
Still, I suspect they are closer to the real problem than simply giving agents larger memory stores and hoping intelligence emerges from accumulated history.
What would a genuinely learning agent look like?
I don’t think the best evidence would be that an agent says it has learned something.
Or that it can summarize its previous mistakes.
Or even that it performs better immediately after receiving feedback.
I’d want to observe improvement over time.
Give the system a series of unfamiliar tasks and let it accumulate experience.
Later, introduce new tasks that require similar underlying skills but look different on the surface.
Does it recognize what matters?
Does it avoid mistakes it previously made for the right reasons?
Can it explain which prior experiences influenced its approach?
Does the improvement survive when the original context is no longer available?
And perhaps most importantly, can it improve in one area without quietly becoming worse somewhere else?
Those questions are harder to turn into an attractive leaderboard.
They also require longer evaluations than most model benchmarks are designed to provide.
A model can score exceptionally well on a fixed collection of problems without demonstrating that it can become reliably better through its own future experience.
That’s not a criticism of benchmarks. They measure important capabilities.
It’s a reminder that learning across a lifetime is a different capability from solving difficult problems with the intelligence you already have.
I suspect we’ll eventually need to measure both.
The gap between intelligence at a moment and intelligence over a lifetime
There’s a phrase I’ve been using to think about this distinction.
Intelligence at a moment versus intelligence over a lifetime.
Today’s frontier models can demonstrate remarkable intelligence at a moment.
Give them enough context and the right tools, and they can do things that were difficult to imagine a few years ago.
They can write software, analyze unfamiliar material, develop complex arguments, and contribute to research.
But lifetime intelligence asks something else.
Can the system continue accumulating useful experience as the world changes?
Can it revise beliefs without losing track of what it knows?
Can it improve strategies without allowing temporary failures to become permanent misconceptions?
Can it adapt to new environments while maintaining reliable boundaries?
Can it keep getting better without depending entirely on a human organization to retrain, reconfigure, or manually correct it?
These are not all-or-nothing capabilities. Today’s systems already demonstrate parts of them, and different approaches may solve different pieces.
But I don’t think we’ve put the pieces together into a generally reliable, open-ended learning process.
And I’m not convinced that simply increasing inference-time compute or extending agent runtime will close that gap by itself.
A model that thinks for ten hours may solve a harder problem than one that thinks for ten minutes.
An agent that runs for ten days may accomplish more work than one that runs for an afternoon.
Both are meaningful improvements.
But neither guarantees that the system will be more capable on day eleven because of what happened during the previous ten days.
That’s the difference I want to keep in view.
The question I keep returning to
For AdamI, I don’t see this as a reason to rush toward self-training or autonomous modification of the model.
We’re still working through more immediate foundations: memory, task continuity, execution boundaries, and ways to inspect what the system actually did.
Those things matter because meaningful learning depends on knowing what happened in the first place.
If the record of an experience is unreliable, learning from it is risky.
If a task outcome cannot be verified, treating it as evidence of improvement is premature.
And if a change in behavior cannot be traced, it becomes difficult to tell whether the system is learning or simply drifting.
So the near-term work is less glamorous than the idea of a self-improving intelligence.
It’s about making experience understandable enough that future improvements could be evaluated rather than assumed.
I think that’s a useful direction, even if it takes us a long time to reach anything resembling genuine continual learning.
Because the deeper question is not how much history an agent can accumulate.
It’s whether that history can make it better, in ways that remain useful when the world changes.
We’re making impressive progress on agents that can keep working.
The next question is whether they can keep growing.
And not just growing in capability, but learning how to change without losing what already works.
The real AGI breakthrough may not be a model that can think for longer.
It may be a system that can learn throughout its lifetime — and still remain reliable as it changes.
The AGI Gap — Exploring what is still missing between today’s powerful AI systems and genuinely general, long-term intelligence.