Self-evolving models

Introducing self-evolving models

Waseem AlShikh

FIG. 01 Score what is unfamiliar → Focus learning on the gaps → Write into layer memory → Use it next time
Identifier
WRITER Research
Published
Nov 20, 2024
Authors
1
Type
Research post
Area
Enterprise-optimized models

In one paragraph

Models that keep learning after deployment. A memory pool built into each transformer layer, uncertainty-driven learning and a self-update step let the model absorb new facts without full retraining.

mechanisms: layer memory, uncertainty scoring, self-update
3
mechanisms: layer memory, uncertainty scoring, self-update

FIG. 02: Mechanism

How it works

  1. Score what is unfamiliar

    As input arrives, the model gives each part an uncertainty score. High scores mark things it does not already know, like a new product name.

  2. Focus learning on the gaps

    Learning concentrates on the high-uncertainty inputs instead of everything the model reads.

  3. Write into layer memory

    Each transformer layer has its own memory pool that feeds into attention. The self-update step merges the new knowledge into these pools without retraining the whole model.

  4. Use it next time

    Later requests can draw on the stored knowledge, so the model answers questions it could not answer before.

FIG. 03: Interactive figure

Teach it the NovaPhone

Pick a new input, set how unfamiliar a span must be before the model learns it, then write it to memory and compare the answer before and after.

Loading interactive demo…

FIG. 04: Notes

Summary

A model’s knowledge is normally frozen at training time. Self-evolving models add three mechanisms that let them keep learning:

  1. A memory pool in every layer. Learned memory sits inside each transformer layer and influences attention.
  2. Uncertainty-driven learning. The model scores how unfamiliar each input token is and concentrates learning on what it doesn’t yet know.
  3. Self-update. New facts are merged into the memory pool, so later answers reflect them.

The post also covers the safety side of continual learning. Models that learn from unfiltered web data can drift: on the R-Judge safety-risk benchmark, self-evolving models that learned from web data scored 21.3%, against 66.7% for traditional methods. Self-evolution needs guardrails. The models are in internal testing and are not publicly available.