Over the past year, Coding Agent has been rapidly changing the way developers write code.
Claude Code, the Codex, are already able to understand code libraries, locate bugs, modify code across files, run tests, and even independently complete complex development tasks. They are becoming more and more like a team of engineers really involved in projects.
But as soon as it enters long-term development, an unusual problem soon arises:
Agents are writing more and more code, but it's still the first time they've been on the project.
For example, a developer has just completed an authorization system modification with Codex.
In several rounds of collaboration, Agent already knows: why projects adopt the current authorization architecture, which historical codes cannot be easily modified, which programs have been tried before but have been abandoned because of compatibility issues, and when modifying databases, it must ensure that the old version is upgraded smoothly.
These are not simply information that can be obtained by reading through the code, but a real development project experience left behind.
The question is, what about the next day?
Reopening a dialog, the Agent may start scanning the same code again; the context that was explained yesterday needs to be re-explained, a failed solution may be proposed again, and a question that has just been examined may be re-investigated.
The dialogue is long enough, as early information is compressed, and so is the change from the Codex to the Claude Code.
So we have an increasingly clever coding agent, but we're still doing one thing over and over again:
Let it re-identify the same project.
When a coding agent moves from a one-time programming tool to a long-term collaborator, it requires not only a larger context window, but also a continuous accumulation of the ability to know what's worth leaving behind and when to think about it again.
This is exactly the problem MemoraX Code is trying to solve.
It came back the next day and it knew what happened yesterday.
If the Agent really has long-term memory, the most immediate change is not just a button on the memory button, but a lot of things that need to be reinterpreted begin to disappear.
The day before, the developers and Codex completed a task and formed some experiences about the project in the process.
The next day, a completely new dialogue was reopened, with the developers not copying yesterday's chat record or re-explaining the entire project context.
However, when the new task again involves the relevant modules, the experience accumulated in the past will re-enter the current work and continue to influence the Agent's judgment.
New dialogue, project experience is not zero.
The new dialog automatically uses the previous round of tasks created by Memory.
This continuity does not need to be tied to an agent.
Developers can complete one task in Codex and then switch to Claude Code to deal with another.
Agent switched, and the project memory is still there.
In the Codex, memory is formed and Claude Code is used directly in subsequent tasks.
Even if the same agent is always used, the dialogue in long tasks will inevitably be sorted and compressed.
But the problem is that compressed content often confuses two types of information.
One class is irrelevant details, such as inefficient attempts, debugging outputs, or reinterpretations in between; the other class is critical experience, such as constraints that require modification of the module to be compatible with an older version of the database, which may have occurred only once, but will play a decisive role in subsequent reconstructions.
Compaction solves the problem of how to avoid context bias, but it does not guarantee which experiences should be retained.
This is exactly what the MemoraX Code is trying to do: allow critical information that has been compressed into history to be identified, extracted, and re-introduced into the context at the right time during subsequent tasks.
Compressed critical information recalled in new missions
Long-term memory is not about trying to permanently preserve every conversation.
On the contrary, what it really needs to address is: leaving behind things that are still worth remembering in the future from the ongoing development process.
Memory is not just about remembering, it's about learning how to remember.
As you can see here, a natural question is: Why do we need an independent memory if the agent itself is able to preserve historical conversations and process more and more information at once?
For the real difficulty is not to preserve more history, but to judge:
What is worth remembering, what is obsolete, and when should it be reconsidered?
MemoraX Code builds local code storage memory and long-term memory in the cloud: the former helps the Agent to quickly understand the current structure, key inputs and historical evolution of the code storage; the latter continues to carry cross-task, cross-dialogue, cross-agent project experience and developer habits.
When the new task arrives, the system does not repackage the entire history into the model, but only finds information that is truly relevant to the current one.
But we think that this is still not the end of coding memory.
Today, many memory systems still rely heavily on artificial rules: engineers dictate what to write, how to organize, and when to recall through hints and pre-designed strategies.
MemoraX Code hopes to further transform these judgments into an ability to be continuously improved through training.
Around the coding scene, we constructed dedicated memory training missions and long-range development tracks, and established evaluation and reward mechanisms for Memory. The system not only judges whether a piece of information has been memorized, but also learns further:
Did it really help Agent make better decisions in the ensuing mission?
Based on these training signals, memory models can continue to learn what is worth writing, what should be updated, what experiences should be refined, and what tasks should reappear.
Supporting this process is a set of basic systems used to train and test the Agent, including the ability to run environments, execute tasks, score feedback, evaluate effects and distribute training. In architectural design, this training system is separated from the user's private memory data.
We want Memory to move from rules to data and rewards, so that Agent not only has memory, but also learns how to remember better.
Do you know what memory is?
How to make Coding Agent better?
The most direct way to determine if Memory actually makes a Coding Agent better is to test it in a standardized Coding Memory Benchmark.
MemoraX first scored 62 points on the Coding Track of the recently highly-acclaimed AML (Agent Memory Leaderboard) event, placing first, a 10% improvement on the industry's mainstream program Claude Mem.
In addition to the Benchmark assessment, we would like to answer a further question:
Can the development tasks that have been completed in the past be automatically absorbed into the next iterative engineering experience?
From remembering what happened, to learning what to do next.
For this purpose, the MemoraX Code supports the automation of Procedure Memory construction.
It can automatically identify solutions with replicable value from historical coding trajectories, further refine the analysis, execution and verification steps of a single task into a structured engineering experience, and ultimately immerse itself in the form of Skill for direct use in subsequent similar tasks.
In one set of experiments, the MemoraX Code automatically refined 15 engineering experiences from 123 historical task segments, further classifying them into four categories of Procedure Memory.
Procedure Memory is automatically refined
What is left here is no longer just:
What happened last time?
It's a great way to learn more.
In the face of this type of engineering problem, what methods of analysis, execution steps and verification methods have proven to be effective in the past.
This is also the way we understand Memory from recording history to learning from history.
Will the experience you've learned really help you on your next mission?
The real verification is the next step.
We used these automatically refined Procedure Memory for a new, complex development task that lasted about three hours.
The agent still needs to understand its own requirements and code, modify implementation, run tests, and deal with the new problems that arise in the process. The only difference is that it can use engineering experience that has been absorbed in past development.
The results show:
The overall score is 11.71 → 70.30
Key check items passed by numbers: 2/13 → 10/13
Procedure memory results for complex long-range tasks
This means that Procedure Memory is not just about remembering historical information faster.
The experience of engineering that has been verified in the past has begun to be really involved in solving new problems.
In addition, this improvement is not replaceable by more model calls.
According to the API single-price calculation of the model used in the experiment, the total call cost was about $31.48 without Procedure Memory; it dropped to $24.37 after use, a decrease of about 22.6%.
The reason is very intuitive.
In the absence of historical experience, the agent needs to re-understand the problem, try out the program, find the error, and constantly adjust the path. Many model calls actually consume on re-exploring what has been explored in the past.
Procedure Memory gives the Agent not a ready-made answer, but methods and pathways to solve problems that have been verified in the past development process.
Agents still need to understand, reason and execute their current tasks, but not from scratch every time.
Memory is not just a record of history, it is beginning to turn history into experiences that can be repeated in the future.
There is another question: will it make itself smart?
Memory doesn't get better the more you recall it.
A change in front-end style shouldn't suddenly come up with a database migration experience a few weeks ago; failed project decisions shouldn't continue to interfere with current tasks.
In internal testing, MemoraX Code 85.5% of memory triggered behavior was consistent with user judgments, and 81.2% of memory content received positive feedback.
It measures another capability:
Not only should you remember, but you should also think about it as well as you can.
Currently, MemoraX Code has completed support for the four mainstream coding agents Codex, Claude Code, Deepseek Harness, OpenCode, and other platforms are continuing to adapt. Once installed, developers can also view and manage their own Memory in the Platform, including modification and deletion.
MemoraX Code official website:
The MemoraX Code memory platform:
MemoraX Github：
Written at the end
In today's Coding Agent competition, a lot of attention is still focused on one task:
Who writes code faster, who deciphers bugs stronger, and who can complete more complex software engineering tasks.
But real projects aren't one-offs.
The same code store is opened repeatedly, the same type of problem occurs again, and a developer may switch between different coding agents.
When the Agent really gets into long-term development, the gap may no longer be just: how far it can go for the first time.
And the tenth, is it still necessary to start from scratch?
The ability to model determines how far one can go, and memory determines where to start next.
MemoraX Code is solving this problem.
Welcome to the MemoraX Code official user group
