Dual-Memory Optimization for Self-Improving AI Agents

Discover AI presents a dual-memory optimization approach enabling recursive self-improvement in AI agents, boosting long-horizon task performance.

Ask about this video. Answers come from its transcript only — with the timestamp, so you can check them.

Generated from the transcript and can be wrong — check the timestamp.

Key Takeaways

Dual-memory structure enables dynamic, recursive self-improvement in AI agents.
Significant performance boosts in long-horizon tasks and reduced failure rates.
Focus on harness memory optimization rather than model weight training.
Working memory tracks current task state; experimental memory stores skills and experiences.
The system learns from failures and adapts skill usage to evolving task complexity.

What the video covers

The video introduces a dynamic dual memory structure for recursive self-improvement in complex AI agents.
Performance improvements are demonstrated across frontier models like GPT 5.6, Opus 5, and open-weight models such as Qwen 3.6 and IBM Granite.
The dual memory consists of a working memory (clean desk) and an experimental memory (filing cabinet) that dynamically interact.
This structure addresses the 'goldfish brain syndrome' by maintaining an accurate task state and aligning skills with evolving task complexity.
The approach significantly reduces long-horizon failure rates by up to 80% and improves task success rates by 12-25 percentage points.
Recursive self-improvement is achieved by continuously updating memory states and skill sets based on feedback from task execution.
The method focuses on optimizing the AI harness memory structure rather than the LLM tensor weights.
A GitHub repository is provided for immediate implementation of the dual-memory system.
The system tracks unresolved goals, dynamically selects appropriate skills, and learns from failures to improve future performance.
Limitations and drawbacks of the approach are acknowledged and discussed towards the end of the video.

Chapters

What is the main innovation presented in this video?

The main innovation is a dynamic dual memory structure for AI agents that enables recursive self-improvement by separating working memory and experimental memory to better handle long-horizon tasks.

How does the dual memory system improve AI performance?

It improves performance by maintaining an accurate task state in working memory and dynamically selecting and updating skills from experimental memory, reducing failure rates and increasing task success.

Does this approach involve retraining the AI model weights?

No, the approach focuses solely on optimizing the AI harness memory structure and skill management without retraining the underlying LLM tensor weights.

Full Transcript — Download SRT & Markdown

Speaker A

Hello community. So, the main insight of today's video will be: we need a dynamic dual memory structure here for a recursive self-improvement of our complex AI agents. Interested? So, let's start. And I want to show you the performance of this new idea, of this new technology, of this new memory optimization with a dual layer memory structure. Now, we go here and they did a beautiful job here for frontier models and you have your GPT 5.6 soul and you have your Opus 5 and you see four particular benchmarks here. They have really an improvement again of 23 percentage points, 17 percentage points, or Opus even 15 percentage points. So, this is significant, but you know what's really nice also with open weight models like a Qwen 3.6 at 27B, you still have this performance increase 16 percentage points here or even if you go down down here to IBM Granite 3 billion, you jump from 9.7 to 23, so plus 13.4 percentage points. So, this seems to work here on our huge proprietary models and our beautiful local models here, Qwen models here. So, interested? Let's have a look.

Speaker A

What are they doing? They are even improving their long horizon performance. So, if you have jobs that are running here for hours, they yeah, even they improve their task success rate. And I think successfully with plus 12%, plus 25 percentage points. So, anyone might say, "This is amazing." And you know what? It reduces the failure mode here up to 86%.

Speaker A

I mean, come on. If this is shown to you as a new technology, would you like to implement this here on your local machine or your cloud-based computer?

Speaker A

And this is here a new study. This is here by National University of Singapore, Stanford University, Princeton University, and University of Oxford.

Speaker A

Beautiful authors, and they tell us here August 25th, 2026. We have now a recursive experimental working memory evolution that is particularly focused here on the long horizon agent harness complexity. So, we will have a recursive self-improvement here of certain particular the memory structure of what a harness complexity. Stanford and Princeton? Yes, let's go.

Speaker A

So, if you weren't in my simple word, what are we doing? Researchers just cured AI's goldfish brain syndrome if it comes not to long-running task. And this is just gorgeous.

Speaker A

And I showed you here the performance. So, this recurs, as the authors call here the new technology upgrade, means in very simple words, if you just want to understand here the basic principle, we have, if you want here, two types of memory. We have a clean desk in front of us. This is our working memory. This is where we work, where we interact with.

Speaker A

Plus, in the background, we have an organized filing cabinet, which they intuitively fetch here from this cabinet specific files exactly at the moment that we need it, exactly at the skill level that is necessary for the experimental memory [clears throat] to contribute here in a particular way to the working memory performance. This is it. This is the whole paper.

Speaker A

This is the main idea. Interested? Let's go on. So, what they are doing, they're giving us a dual memory structure here for our AI evolution. And remember, we are not optimizing the tensor weight in the LLM.

Speaker A

We go out in the harness, and in the harness, we just look for memory structure. We go here for a limited harness self-optimization.

Speaker A

This is great, but it has also some drawbacks that we'll address at the end of this video.

Speaker A

So, another effect the authors show us that we can wipe out up to 80% of the long horizon failure rates even on bleeding edge frontier models like Opus 5. I mean, come on, this is nice. Plus, of course, and open weight models.

Speaker A

You know, you say, "Great. So, how were they able to achieve? How did they came up with this new technology?" Well, at first, they looked at what is the problem that we have currently. Why are we not here at a better performance with our AI models? And they identified the problem is capabilities are mediated by an harness, of course, no?

Speaker A

And yet, achieving recursive self-improvement remains a fundamental challenge, particularly in the long horizon task, where our goals, our observation, and the failures continuously evolve with a recursive self-improving AI system throughout the execution. And as I told you, our AI system becomes mixed up. We have what they called a the goldfish brain time here. The AI is not able to really understand, "Hey, these are my long-term commitments. These are my short-term modification. And now I have to bring everything into a coherent set of action and observation and analysis and of skill requirements and what other skills missing and analyze here the complexity of the task and and and and after some time the model is just mush.

Speaker A

Forget about it. So, therefore, they say a capable harness must do more than just provide a fixed set of tools or a fixed set of memories, a fixed set of skills. It must maintain an accurate understanding here, "What is my current state? What is the current task state that I as an AI system am in?" And then, invoke appropriate experiences, like let's say a skill, as new requirements emerge. Understand, "Okay, the complexity of the task makes now a jump at the step two. So, therefore, maybe I need some more advanced skill sets. And turn here also execution failures.

Speaker A

If something goes wrong, the system says, "Hey, wait a minute. I want to understand what went wrong. At what step did the failure happen? At the memory structure? At the decomposition? At the compactification?" I want to understand I want to learn from my mistakes.

Speaker A

Make these mistakes here further future improvement that will affect your my future behavior. So, I, as an AI system, I can continuously self-improve with a recursive loop. And yeah, we're going to talk about looping quite a lot.

Speaker A

So, as the interaction history grows now for this AI system, agents often lose track of the unresolved goals of multiple subgoals and invoke skills that are no longer aligned with the current task state complexity.

Speaker A

So, this is something that we call, as I told you, the goldfish moment, yeah?

Speaker A

Now, this long horizon execution exposes a central obstacle to RSI. Agents may accumulate experience while the memory mechanisms with which the harness organizes this selected and improves that experience remains largely fixed and the memory is not in the dynamic mode for the particular state that we need for better performance. So, the central limitation is not simply the absence of useful experience in our skill database, but the lack of a compact and reliable task state that the AI is in that can continuously align stored experiences with the agent's current execution needs. So, that AI system understands, "Hey, I'm now in complexity level 17, and now I need some dynamic new skills, maybe." So, let's have a look how they solve this problem. Let's look at it solution now. And it's that simple. We have now the clean working desk. This is our working memory. And this provides now the missing state representation. So, the job of the working memory is simple.

Speaker A

Now, this is my operational surface on the desk. This is where I have all clearly see this is my current state.

Speaker A

This is my current goal. This is my current um definition of the task. These are the subtask I define. This is what I already achieved, and this is what I set out to do next.

Speaker A

And this, if you want, working memory continuously tracks now the agent current progress and all the unresolved goals, the future possible steps, and uses them to select now the most appropriate skills from, guess what, the experimental memory.

Speaker A

So, the idea is simple, but they found a very beautiful mathematical solution, and they also provide here the GitHub uh repo so you can implement it immediately.

Speaker A

So, after this particular skill that the AI system decided now, hey, I have to import the skill, implement it, execute the skill, we have now a feedback. We have a feedback from the action that the LLM takes now based on the skill, and

Speaker A

Forget about it. So, therefore, they say a capable harness must do more than just provide a fixed set of tools or a fixed set of memories, a fixed set of skills. It must maintain an accurate understanding here, "What is my current state? What is the

Speaker A

current task state that I as an AI system am in?" And then, invoke appropriate experiences, like let's say a skill, as new requirements emerge. Understand, "Okay, the complexity of the task makes now a jump at the step two. So,

Speaker A

therefore, maybe I need some more advanced skill sets. And turn here also execution failures.

Speaker A

If something goes wrong, the system says, "Hey, wait a minute. I want to understand what went wrong. At what step did the failure happen? At the memory structure? At the decomposition? At the compactification?" I want to understand I want to learn from my mistakes.

Speaker A

Make these mistakes here further future improvement that will affect your my future behavior. So, I, as an AI system, I can continuously self-improve with a recursive loop. And yeah, we're going to talk about looping quite a lot.

Speaker A

So, as the interaction history grows now for this AI system, agents often lose track of the unresolved goals of multiple subgoals and invoke skills that are no longer aligned with the current task state complexity.

Speaker A

So, this is something that we call, as I told you, the goldfish moment, yeah?

Speaker A

Now, this long horizon execution exposes a central obstacle to RSI. Agents may accumulate experience while the memory mechanisms with which the harness organizes this selected and improves that experience remains largely fixed and the memory is not in the dynamic

Speaker A

mode for the particular state that we need for better performance. So, the central limitation is not simply the absence of useful experience in our skill database, but the lack of a compact and reliable task state that the AI is in that can continuously align

Speaker A

stored experiences with the agent's current execution needs. So, that AI system understands, "Hey, I'm now in complexity level 17, and now I need some dynamic new skills, maybe." So, let's have a look how they solve this problem. Let's look at it solution

Speaker A

now. And it's that simple. We have now the clean working desk. This is our working memory. And this provides now the missing state representation. So, the job of the working memory is simple.

Speaker A

Now, this is my operational surface on the desk. This is where I have all clearly see this is my current state.

Speaker A

This is my current goal. This is my current um definition of the task. These are the subtask I define. This is what I already achieved, and this is what I set out to do next.

Speaker A

And this, if you want, working memory continuously tracks now the agent current progress and all the unresolved goals, the future possible steps, and uses them to select now the most appropriate skills from, guess what, the experimental memory.

Speaker A

So, the idea is simple, but they found a very beautiful mathematical solution, and they also provide here the GitHub uh repo so you can implement it immediately.

Speaker A

So, after this particular skill that the AI system decided now, hey, I have to import the skill, implement it, execute the skill, we have now a feedback. We have a feedback from the action that the LLM takes now based on the skill, and

Speaker A

this environment feedback verifies now the progress and updates now here our WM, our working memory, simply the observation. We have coming in a new observation to our LLM where the environment gives us a feedback and says, "Yeah, this skill worked or it did

Speaker A

not work at all." Okay. So, what we build? We build a loop. What a surprise, no? As a subscriber of my channel, you say, "Okay, beautiful loop." Now, we have the task state. Then we have given our particular task state

Speaker A

that we are in and the complexity level that we are in at step 17, we have now a particular skill selection. This skill selection gives us now an execution.

Speaker A

This execution gives us a feedback from the environment since we have a direct contact here with the environment. If there is a problem, if the harness is an active harness, but remember we are only looking here at one single element of

Speaker A

the harness complexity in this is the memory structure. And from this feedback from the environment, we have now an updated task state, successful, unsuccessful. Yes, skill is useful, not useful.

Speaker A

And great. Now, what is happening is by explicitly connecting now to task state all the selected skills at a particular loop depth, [clears throat] all the actions by the LLM, and the execution outcomes, and therefore the observation from the environment, we

Speaker A

have now a coupling. We have a coupling now by the experimental memory and the working memory, and this turns here this agent harness execution into what they call here a structured evidence gamma.

Speaker A

This structured evidence here, this coupled here between the two memories, is the main mathematical idea, the main code idea you really have to understand.

Speaker A

This is the evidence about how memory affects here the behavior of the agentic system or the agent itself.

Speaker A

And of course, and this is now also for this recursive self-improvement, they say, "Listen, sometimes the job goes wrong. So, we will have a failed trajectory, but in this failed trajectory, since we recorded every single step, we now understand

Speaker A

the failed trajectory can be localized to a specific memory component. And since everything is more or less file-based, now this enables, if you want them curatorial repair process that can start now, rather than rewriting the entire memory system no?

Speaker A

So, this is here there the specificity of the repair process that they are quite proud of.

Speaker A

Because I will show now the specific memory component register that I built. But just for you to have here this this this inner image that you have in your mind now. We have here the core. The core is our LLM

Speaker A

with the weights. And we don't touch the weights. We don't train the LLM here. We don't do nothing. We just provide you in a context window here to the frozen LLM here all the information of context and we receive the action by this model.

Speaker A

Everything else, all the dynamic, all the quotation mark learning, we just export to the harness. And in the harness, we just look at here the memory optimization method dual memory layer structure.

Speaker A

So careful. This is again an example where the LLM, the core intelligence of our agent, is not learning itself, but it relies here on the complexity on the data provided here by the harness to its context window to

Speaker A

come to a decision, decide on a particular action, and this action will be executed in the environment, and the observation from the environment is our feedback.

Speaker A

And the feedback is now modifying something in the harness, not the LLM itself. Careful.

Speaker A

So within each task it requires now this new methodology uses here the working memory to maintain a verified task state and uses that particular state to invoke the most appropriate skill from the experimental memory.

Speaker A

Now in this experimental memory, we have to have a starting set of some basic skills, but the beauty is it can also build new skills and add this here to our skill bank.

Speaker A

Now across all the task it will now do for you a fixed meta agent. This is now the super intelligent that comes in and is now steering here our learning.

Speaker A

It is, if you want, the main dependent that we are depend on for the running.

Speaker A

So, it's not really a recursive self-improvement because we do have to have a superintelligent agent in the background that now analyzes the resulting structured execution traces with all the information.

Speaker A

Based on the information in these traces, it identifies now a particular memory component that most likely to provide here an effective repair.

Speaker A

And then, it proposes here a localized update to this memory component segmentation. So, this is, if you want here, the main idea.

Speaker A

We depend, however, on this meta-agent that analyzes everything, that understands everything, that analyzes here and understands immediately, "Hey, I see here in memory element 112, this is what we have to optimize." So, yeah, this this dependency here on this

Speaker A

meta-agent is something I'm not really happy with, but okay. So, here we have it now. To say, "Okay, this is how memory was used, how memory is used here, the old, boring, classic way." And now, here with our Recurse Harness,

Speaker A

now we have it is working memory, this coupling of working memory and experimental memory, where we can build new skills, where we have the verification, we have the observation, the feedback from the environment. And guess what? Yes.

Speaker A

Now, what is interesting for the coding experiment, if you look then at the code itself, the mathematics that they build on. So, they have within a single task, we have a task-level execution loop, and they have here the verified coupling

Speaker A

exactly between our dual memory structure. So, here, our working memory and our experimental memory, somehow we have to make them interact in an execution loop, and they showed us here to you. I will give you a different simplified version also maybe a

Speaker A

mathematical more precise version and then they have a second loop and the second loop is of course for the recursive skill memory evolution. I told you we are RSI. So a recursive self-improvement and evolution of the state itself and this is what we call

Speaker A

the cross-task evolution loop. So we have two loops here, one for the particular task and one here for the cross-task for the skill memory evolution. And now the main question is somehow we have to find a mathematical framework that

Speaker A

performs both tasks but also here is integrating here the loop interactions. So these two loops have here a beautiful perfect coherence.

Speaker A

Now the way to do this, how to connect this loop, this is here equation three of the paper.

Speaker A

I told you there's this very specific very beautiful structured execution trace gamma. And here in this particular trace we record everything. So this means all the dependencies and all the elements that are now here within this and you see here with our omega with our

Speaker A

WT, this is the proposed state and we have here the checker. The checker is here abbreviated with C. The checker decisions made after each step here and yeah. Now what is interesting here, you will see we operate here with ET

Speaker A

and this means the skills that are supplied to the LLM but we also have something from a global skill library.

Speaker A

So let's have a look at this but in general the most important object that you have to understand is gamma. This is it.

Speaker A

Because it records the following. This is the trace that you need here for a complete understanding of the system because it tells you it records what the system believed before acting. What is the state of the system, if you want.

Speaker A

Then which skill was selected at a particular point in time during the looping, which action was taken at a particular time during the looping, what environment of returned as an observation at a particular time during the looping, which state change was

Speaker A

proposed as a result of the observation of the environment feedback, what the checker accepted or rejected as a valid reply, the resulting state, so the state plus T plus 1, and then the final outcome.

Speaker A

So, gamma here is our main recording instrument. And the resulting structured trace gamma, yeah, the called structured trace, reveals whether now the failure arose from what object. Was it the wrong skill? Was it that it was not a coherent

Speaker A

state representation? Was it to the retrieval policy for our particular skill selection was not adequate for the complexity of the job? Or did simply the verifier fail to verify that this is the right skill for the job? Or what

Speaker A

happened? So, you see, because we recorded every single data element, now this supreme super intelligent AI can look at this structured trace, understand the complexity of everything interconnected, and come up with a solution.

Speaker A

So, the meta agent, this is my super intelligence, can therefore patch not the responsible component within this structured trace gamma, instead of just rewriting everything and say, "Yeah, let's rewrite the code." So, what they hope for is, yeah, with

Speaker A

this deep understanding of this complexity structured trace, we have now somewhere an AI that understands what to do next.

Speaker A

Now, if you go now for the a loop here, this is now what they call a bounded recursive evolution. This is the system evolution as an RSI system.

Speaker A

So, you might say, "Hey, great. So, we have a memory structure and we have our gamma. Then we have here the if you want diagnosis here, what went wrong, what has to be fixed. Then we have here new

Speaker A

memory system. We have here a gate that verified that this is everything is okay. And then we have from this new memory, well, guess what? We come back and we have now a new trace and yeah, you immediately see this

Speaker A

loop that this process here is recursive because each admission decision changes here the memory control layer used for the future execution and blah, blah, blah. Just tell you look at equation 10 if you want to understand the complete

Speaker A

system complexity. And if you say, "Can you do this in simple words?" Of course, because this is the reason why you watch this video, no? Because equation 10 simply means, "Look, we start with our current memory M.

Speaker A

Then we have here the execution evidence from all the observation and action taken, whatever. Then, because we have this beautiful recording of all the data in the execution, the evidence, we can do a failure diagnosis here, D for

Speaker A

diagnosis here. This diagnosis tells us exactly what went wrong. We have now a super intelligence that comes now in and does a localized memory patching and understand exactly if I have a curacao precision, what elements I have to

Speaker A

modify the code. Then we have this new patch. This means we have now to go over a validation over a particular gate mechanism. We can create now a new memory structure and this new memory will have here a new

Speaker A

behavior of the complete system and this means we have also done a new evidence and we have start again with our loop with a gamma K plus 1.

Speaker A

You might say, "Great. Anything left? Yeah, there are tons of details because the paper has I think 36 pages. So, there's a lot of mathematics for you to discover if you really go a level deeper. Let's start with the main

Speaker A

element that is evolving in the system as part of the harness structure of our agent and this is the skill memory m for skill memory.

Speaker A

Now, this memory contains according to the author here four components that can change. E is our as I told you the experimental memory.

Speaker A

These are all the reusable skills. W here of course here is the working memory specification. The state schemas, the state update, everything that goes here into WK. Now, row is here everything that is retrieved. So, this means here invocation policy, you know,

Speaker A

when and which skills are retrieved at what particular complexity of the particular time in the loop and you got the idea.

Speaker A

And as I told you C stands for checkers. So, this simply means whether observation proved that the goals were completed or not. And this is not just to make sure when the LLM thinks the job is done and says, "Finny, this is it."

Speaker A

No, we have to have an observation coming as a feedback from the environment. We evaluate this observation independently and only when this observation tells us, "Yes, the job is really done." then we get here the flag and say, "Okay."

Speaker A

So, just to make sure Recurse is a partial harness [snorts] evolution system on RSI.

Speaker A

It is not like in my other videos that all components of the harness are modified and not at all that we have here a co- evolution of LLM plus harness.

Speaker A

Recurse is really limited to the harness and within the limited within the harness it is limited to the memory complexity of our dual memory layers.

Speaker A

So, what is fixed? All the LLM weights, all the tools, the meta agent, the failure localization procedure is not dynamic, the patching procedure is not dynamic, the validation gate is defined deterministic, and the harness mechanism outside of this

Speaker A

particular memory control layer all stay the same. So, this is not really a dynamic co-evolving system. This is just absolute laser focus here on our dual memory structure.

Speaker A

Yeah, experience. Now, let's talk about it. So, what we have here is a particular dependencies, and you have it here on ET and EK. So, EK means simply here this is here the complete skill library that is available to this

Speaker A

particular agent, and ET is now given here all the dependency of the task and the verified current working state and the execution event and everything. We have now a small subset ET selected here that is now inserted here into the LLM

Speaker A

context window. So, this is here you don't need all the skills that you have available to your AI system, but there's a selection for a small subset of the skill library, particular skills.

Speaker A

If you want to see it here in an abstraction, I think this is a very nice representation. So, you have your extended trace here. This is our gamma.

Speaker A

This is shows you exactly what happened. And if you know exactly what happened, you have every detail about every element, you know, you have now this a diagnosis element by another AI that tells you exactly, looking at this

Speaker A

trace, what went wrong. Understanding what went wrong, we can have now a new skill, a revised skill, whatever is necessary by this AI's external AI system. So, we can update now our skill library with some optimized skill functionality.

Speaker A

And then, you see, we have now our complete entire library that is available, but we choose now for a particular task, we said, "Hey, we only need a very small specific subset of the library." So, ET are now our skills

Speaker A

needed right now for this particular job, and these skills are provided to the context window of our frozen LLM.

Speaker A

So, EK is, if you want here, a set of reusable skills S1 to SN, external skill written here in a particular agent skill format that is compatible to our agent, and the trace here, our gamma K, supplies here the evidence

Speaker A

[clears throat] from which the meta-agent distills here a general procedure, and this might be a new or revised skill.

Speaker A

So, you see, everything is here the dynamic element here is our dual memory structure layer.

Speaker A

Now, if you have this stack with the selected experience now, we have now an action. So, the frozen LLM receives this now in its context window. So, what we have? In this front context window, we have the task X, the complete

Speaker A

interaction history H, the compact working state WT, and the selected experimental skills ET. This was the reason why we did all of this, now, a subset of our skill library that are absolutely necessary for this particular job. And now, the LLM

Speaker A

produces here a particular action A. It decides, "Given all this data that I received here in my context window, this is not a next step." Action A, and the environment, when executed, returns, based on this action A, now the result,

Speaker A

the feedback, the observation from the environment O. And if we have this, then, simple, now, we propose, verify, and commit the new state.

Speaker A

So, working memory proposes that the state changed, the checkers compares now the proposal with the external evidence from the environment, and then we commit here the fixed kernel exacts here only the supported changes. So, if you want, the goal becomes

Speaker A

done, or a goal is acknowledged here as completed only if the environment observation supports it and not if the LLM decides, "Hey, I'm done now. I go and have a lunch break." If you want to see this, look at the

Speaker A

equation five. This is really here, if you want to understand this this interplay here with the working memory specification proposes here the next state. This is it.

Speaker A

You have here clearly you see here your UW builder, and then you have the checker, and then you have your pure W, your pure, if you want, next state here of the system that is now checked and verified.

Speaker A

So, if you want simple terms, the recursive loop in this particular paper here is we start here with a skill memory, and we end up with a new skill memory for a particular job, and we run through our recursive loop where we have

Speaker A

here a new harness behavior. This new harness behavior leads to a new execution evidence of the LLM, since new data and new skills are provided in a context window of the LLM. This might have here a failure, but this is great

Speaker A

because we have here with this failure we use the failure to have a diagnosis on this failure, to learn from this failure, optimize here the skills, send it back here and have a new skill memory that is now optimized.

Speaker A

So, any validated lesson from the experience becomes simply a reusable external skill. And please make absolutely sure this is not a training of the LLM. We're absolutely only at the harness configuration, and there only at a very tiny slide of the harness, the

Speaker A

memory. Nothing else. Yeah, result I already showed you want to see this now again in a detailed numerical table, here we are. We have the cross task evaluation here, beautiful skill flow, and within the task adaptation terminal bench 2.1,

Speaker A

luckily not anymore 2.0. Please never use terminal bench 2.0 anymore. And you see here Yeah, wherever you look here, you have here in this pink or red or whatever, this records this new methodology, and they go here from an

Speaker A

IBM Granite 3 billion then to a Q and 3.54 billion to a Q Q and 3.635 billion, and you see you do have continuously an improving in the performance. And if you go here Opus 5 or GPT-5.6 sold, also an improvement

Speaker A

here within the task and in the cross task evaluation. So, this system seems to work rather nicely.

Speaker A

Having read the paper yourself, coming back now, reflecting on the paper, having admired this video, you might say, "Okay, and what are the insights now? What are the deeper insights here hiding in the paper?" Now, what is it?

Speaker A

It is a recursive experimental working memory architecture that reframes the recursive self-improvement as an operation on an externalized memory control layer rather than on the model or here the inner agent itself.

Speaker A

So, this means the working memory maintains a verified task state all the time, and that state grounds here the skill invocation in the experimental memory, and the coupling between these two memory elements here emits a structured trace gamma linking now all

Speaker A

the information, linking all the complexity, linking the task states, the invoked skills, the action, the out the observation coming back from the environment and thereby and the outcomes totally completely in our gamma and gamma is the main object that we can

Speaker A

evaluate, study, and optimize therefore the memory layer. This fixed meta agent here reads this particular gamma trace, attributes each diagnosed failure to a memory component.

Speaker A

Remember, we are not talking about anything else than memory component. So, this might impose a quite strong limitation on the diagnose complexity.

Speaker A

And then this meta agent patches only the memory components implicated behind here a fixed validation gate, of course.

Speaker A

So, if you want to see it here now in one view here, I say, "Okay, what is here the main element to take away?" We do have a frequency of a recursive self-improvement RSI framework that improves a long horizon agent by

Speaker A

evolving its memory instead of the tensor weights of the LLM or prompt complexity or anything else.

Speaker A

We do have a frozen agent. This means the LLM at the core of the agent is frozen. And this is now paired with a dynamic updatable skill memory M. We have four elements that define the skill memory and that we can edit and modify. And the

Speaker A

meta agent reads here the structured execution traces running all the procedures we just described in this video, locates the failure in one component of this memory and patches only that single component.

Speaker A

We have then a deterministic validation gate that decides on a paired held-out evidence whether the patch survives now the validation, yes or not. And this is it.

Speaker A

You have and you see here just they are just filling up here the GitHub repo, but I'm really interested to apply this also to theoretical physics complexity.

Speaker A

Let's see how the improvement is there if we you to a scientific base because I want to tell you the real at the end of the video, there is still a limitation of this, no?

Speaker A

Because this is exactly my question I ended up with. I personally, after reading this paper, and I said, "Okay, but memory is not the only element for learning of an AI system, no?" When memory designs here workflow for

Speaker A

complexity that the parametric knowledge of the LLM that is frozen cannot handle, and we do not train the LLM on this, what are the limitation of this new methodology for this skill memory optimization in [snorts] an external layer to the

Speaker A

LLM? Just think about it, no? I, in my view, I think a workflow is not automatically a new capability that is available to the agent.

Speaker A

Because suppose the memory contains this beautiful workflow here, you construct a mathematical model, you derive the relevant invariant parameters, you design here discriminating experiment, you update your particular mathematical hypothesis on the complexity of the state, and you prove the convergence,

Speaker A

mathematically prove theorem, lemma, you got the idea, no? Okay. So, you have the workflow, but the LLM must be able to do this. Just because you have the description of the workflow is not a capability.

Speaker A

And I think this shows us here the limitation of this paper if you just do it alone, if you would not couple this with the LLM evolution.

Speaker A

Because LLM must be able to formulate the correct model, discover useful invariant, design a valid experiment, interpret the unexpected evidence if something goes wrong, maybe produce a mathematical proof, lean forward, whatever you have available.

Speaker A

So, there's still a lot of what the LLM must have an inherent capability to perform, even if you provide here a beautiful workflow here in pure semantic terms.

Speaker A

So, careful. Just a memory optimization, a skill memory optimization, might not increase the let's call it intelligence of the agent because the LLM itself, the neural network at the core, this is the element who makes all the decision. This is all the This is the

Speaker A

LLM that decides which action to take next. is not trained. So, therefore, what I would say, "Hmm.

Speaker A

Now, [clears throat] if we go into the topic of science and scientific reasoning with AI, no?" Because I think this way might require a my AI system to conclude, "Hey, wait a minute. I as an AI system with all the

Speaker A

beautiful complexity of LLM and harness evolution, my current ontology is insufficient." And this links back to my last two videos. If you've not seen my videos, you will not understand this sentence.

Speaker A

But here, the Recurve's this new paper, this new methodology, as beautiful as it is, has a completely different question to the system, no? Recurve's now ask, "Hey, which existing memory components caused the observed failure?" But you see that this are completely

Speaker A

fundamentally different question regarding the solvability and the complexity and the congruence of this AI model.

Speaker A

So, you see, this Recurve's paper is beautiful. It gives us another step ahead. But think about it. It is just one little puzzle piece that we have now in addition.

Speaker A

But in itself, it is not enough to have here AI working here on anything in science. We just improved for the known elements, for the known skill, and a little bit of domain-specific skill evolution. Yes, there it will work

Speaker A

beautifully. But in most we go to something unknown, yeah, we will encounter some problems if we decouple the memory optimization from the LLM optimization itself, and therefore, I have a feeling that the co-evolution from LLM and harness complexity, they have to go hand in

Speaker A

hand. If you disagree with me, but only as a subscriber to my channel, yeah, please leave a comment. I'm looking forward.

Speaker A

Hope you enjoyed it. Hope you had a little bit of fun, some new insights.

Speaker A

Think about it, and it would be great to see you in my next video.

Topics:dual memoryrecursive self-improvementAI agentsworking memoryexperimental memorylong horizon tasksmemory optimizationAI harnessskill selectionfailure reduction

Get More with the SozAI App

Transcribe recordings, audio files, and YouTube videos — with AI summaries, speaker detection, and unlimited transcriptions.

App Store Google Play

Or transcribe another YouTube video here →

Free tools: TXT to SRT · SRT Validator · Merge SRT · Subtitle to Text · All tools