Retraining the model
is slow, fragile and hungry.
The usual way to improve an agent is to retrain it. Each round has three problems:
It takes too long. A lesson from this morning may not show up until the
next training run finishes.
It forgets the wrong things. Improving one kind of work can damage
another, because everything shares one model.
It needs a lot of examples. Real work produces a few, late, messy
signals — not the pile of examples a training run wants.
The insight
People keep two jobs apart: the ability to think, and the memory that learns from what happened. Fast learning is a change in memory, not a rebuild of the mind.
NCL does the same for an agent. The model stays the thinker. A separate memory holds experiences, facts, and relationships. Learning is an update to that memory — quick enough to happen as the work is done.
Five phases of the framework.
Each phase is one job the memory does. Together they are how an agent learns without a training run.
Notice the surprise
Before a task, the agent guesses which memories it will need. Afterwards, that guess is compared with what it actually used. A correction from a person, a failure, or a retry all count. The bigger the gap, the more the experience matters.
Strengthen or weaken the memory
A success makes that memory easier to find next time. A failure makes it less so. A correction from a person counts too — the agent can learn from being stopped before it fails. Memories that show up together grow a stronger link.
Recall by association
A question wakes the memories that match, and those wake related ones through the links between them. What comes back is a path you can follow, not a hidden similarity score.
Let unused memories fade
What is not used grows quieter, the way an unused recollection does. Using a memory resets that fade. Forgetting here is how the memory stays usable, not a defect.
Settle what was learned
A later quiet pass looks back over recent experiences. What kept working is promoted. What kept failing is turned down. Repeated pairings become lasting links. Noise is set aside.
One task, from arrival to memory.
The phases run inside a single pass. Here is that pass, in the order it happens.
A message arrives
The agent receives the task and keeps it with the conversation it belongs to.
It makes a guess
Before it acts, it names the memories and habits it expects to need. That guess is what the outcome will be compared with.
Practised habits can step in
A familiar pattern can bring a well-used habit straight into the working set. Unfamiliar work does not fire on its own — it waits to be chosen.
Related memories are gathered
The question wakes matching memories, and those wake neighbours through their links. The most relevant ones enter a limited working set. There is only so much room, so the strongest come first.
The agent acts
It works with that set in front of it. What it actually opens is recorded.
The outcome is compared with the guess
Success, failure, a correction, or a retry tells the memory how surprised it should be.
The memory is updated, then cleared
The experience is stored. Memories that helped are easier to find next time; memories that misled are quieter. The working set is wiped so nothing leaks into the next task.
A later pass tidies up
What went unused fades. What kept repeating is settled into longer-lasting links, and noise is set aside.
Fast when it's routine.
Deliberate when it matters.
Some memories arrive as habit. A practised skill that matches the message can step in on its own — the way a familiar action does not need a decision. Anything that is not yet practised waits.
The rest is deliberate. The agent goes and looks: it follows links, asks what is related, and records what it actually used. Even a careful look leaves a trace, so the next guess can be better.
A limited working set
The agent does not hold everything at once. Memories compete for a small working set. The most relevant are admitted first, and at least something gets in. When the task is over, the set is cleared. The next task starts empty.
Surprise, not repetition.
One surprising event teaches more than many routine ones — the same asymmetry that makes a single vivid mistake stick, while a hundred ordinary repetitions barely register.
A third outcome: corrected
Success and failure are not the only lessons. A person can stop the agent before it fails. That correction is strong evidence the guess was wrong, so the agent learns from the near-miss without having to fail first.
What it adds
Looking things up finds a passage and moves on. NCL closes the loop: every task leaves the memory a little better shaped for the next one. Retraining changes the thinker. NCL changes what the thinker remembers.
Memory versus
retraining.
Retraining changes the system that reasons. NCL changes the system that remembers. Getting better at one kind of work does not damage another, because the memory can be specific while the model's general ability stays intact. NCL sits beside training. It does not replace it.
| Property | Retraining | NCL |
|---|---|---|
| What changes | The model | The memory |
| How soon | After a training run | As the work is done |
| Forgetting the wrong thing | A real risk | The model is left alone |
| How many examples | Many | One vivid event can be enough |
| Can you see why | Rarely | The path through memory is visible |
| One domain vs another | Shared | Memories can stay separate |
| What counts as an outcome | Reward or penalty | Success, correction, or failure |
Known limitations.
A framework that hides its boundaries isn't a framework. These are part of the research, not footnotes to skip.
It needs a clear outcome
The quiet pass is on a fixed rhythm
The reference starts from the words in the question
The balances were chosen by trying them
No formal proof of settling
NCL, in short.
Does NCL fine-tune the language model?
How is NCL different from looking things up?
What makes it learn from so few examples?
Can you explain why it recalled a particular memory?
Where does the name come from?
The path to more capable agents runs through better memory.
NCL is the first framework in the Memkist research programme. Interested in the work, or in building on it? Get in touch.