slm · self-learning model

The model that is
never done training.

Every LLM you've ever used is frozen at birth — trained once, shipped, fossilized. This one rewrites its own weights while it runs. There's a live one in this page. Scroll.

▮
weights updated by the model living in this page: 0
01 · the problem

Deployment is a funeral.

The moment a model ships, it stops learning. Every conversation, every correction, every new fact it meets — evaporates when the context window ends. The industry's fixes are prosthetics:

prostheticRAGNotes taped to the model's forehead. Retrieval, not knowledge.
prostheticLong contextA bigger forehead.
prostheticFine-tuningShip the fossil back to the factory.

None of them change the model. Experience should leave a mark.

02 · the idea

Three layers of memory.
Like a brain.

frozen Qwen3-VL-2Bnever updated. can't forget. ever.instinct
+ strands LoRA (merged)slow knowledge, consolidated offlinecortex
+ plastic headfast weights — rewritten at inferencehippocampus

The loss signal is the deepest part: next-observation prediction error. No labels. No reward model. No human feedback. The model predicts what comes next, gets surprised, and rewrites a small bounded piece of itself.

Reality is the teacher.

# the whole loop
for observation in reality:
    surprise = -log p(observation)      # predict → measure error
    if surprise > expected:             # surprise gate
        fast_weights -= lr * grad       # rewrite yourself
        fast_weights *= decay           # bounded — never drift far
03 · don't take our word for it

A self-learning model is running
in this page. Teach it.

This is a real fast-weight character model (vanilla JS, ~200 lines, the same surprise-gate + decay + reset mechanism as the 2B system — miniaturized). It was born knowing nothing.

surprise (nll/char)
—
weight updates
0
gate closed
—
‖fast weights‖
0.00
live belief — P(next char) after "the"
→ press observe a few times, then generate. watch it get less surprised — that IS learning.
⌨ shortcuts: observe · generate · reset. Everything happens in your browser. Refresh = lobotomy (unless you 💾 save the brain). That's the point: weights are the only memory here — no context window, no retrieval, no tricks. reset() provably zeroes the fast weights (the same off-switch guarantee as the 2B model: Δlogits = 0).
04 · the 50-year-old problem, as one knob

Stability ↔ plasticity.
We measured the dial.

Learn new things, or keep the old ones — neuroscience's classic dilemma. On a real 2B model, it reduces to EMA decay on the fast weights. Drag it. These are our actual measurements:

← MAX PLASTICITY (no decay)MAX STABILITY (frozen) →
lr 1e-2 · no decaylr 8e-3 · decay 0.98lr 2e-3frozen
+0.89
learning gain (nll)
+0.03
forgetting (base)
the sweet spot — learns AND retains (lr 8e-3, decay 0.98)

Without the decay: gain +3.3 but forgetting +7.09 — the model lobotomizes itself. With decay 0.98: gain +0.89, base drift +0.03. One knob resolves the dilemma.

05 · receipts

Real numbers. Single GPU.
Reproducible.

claimevidence
It's a domain expertstrands probe NLL 4.85 → 2.22, 8/8 improved
It learns while runningcontinual OOD stream NLL 6.18 → 5.37, pure inference
It doesn't forgetbase expertise during OOD learning: Δ −0.01
Watchable, liveP(correct) 0.09 → 0.74 in demo.ipynb, greedy 3/3
Agent turns → weight changeP(fact) 0.002 → 0.571 over 8 strands-agent turns
Provable off-switchreset() → bit-identical to base, Δlogits = 0
# pip install strands-slm
from strands import Agent
from slm import SLM

agent = Agent(model=SLM("cagataydev/strands-qwen3-vl-2b"))
agent("...")   # ← this turn PHYSICALLY changed the model's weights
06 · what we could NOT do

The negatives are the science.

Two independent experiment tracks — run blind to each other — hit the identical wall:

Memorization ≠ knowledge. Fast-weight NLL gains grow huge (+1.4) while generated answers get worse. Probability mass moves toward the fact; the argmax stays captured by the prior.
Sequential facts interfere. Teaching fact 2 crashes fact 1: P 0.571 → 0.090 at high plasticity.
A single plastic layer can't store facts. It reshapes output priors; retrievable knowledge lives in mid-layer MLPs. Rehearsal on unrelated text doesn't save it — the interference is in the shared low-rank subspace.
⚗ REPRODUCE THE NEGATIVE — right here, with the page-model

Teach it fact A until mastered, then hammer fact B, then ask about A again. Watch high plasticity overwrite — the same interference we measured on the 2B model (P: 0.571 → 0.090).

→ 30 observations of A, 30 of B, then recall A. no tricks — it runs the model above.

And the deepest finding: making test-time learning store durable knowledge requires multi-layer placement + replay + consolidation… which is distillation, running continuously.

Fast weights catch experience.
Slow weights consolidate it.
Wake and sleep.

Biology needed both. Now we've measured why.

07 · why this matters

Models as living systems,
not artifacts.

Every agent framework improves by changing prompts, tools, retrieval. This is the first where using the agent changes its weights. Run it for a month and it's no longer the model you downloaded — it's your model. With a reset button, and an audit log of every surprise that changed it.

The thing that comes after
"training runs."

teach the live model