Can’t diverge while learning, and doesn’t have to overwrite what it already knows.

Adaptive covers a lot of ground now: inference-time tweaks, adapter matrices, on-device learning that never touches the weights that matter. The paths that do update live pay for it in old knowledge: catastrophic forgetting. Bounded state is out there; bounding weights while they keep learning in the field is what has been missing.

So the claim is the conjunction: a tiny network that keeps updating on the device after deployment, bounded by construction while doing it and without wiping what it holds to make room for what’s next.

Any model that keeps updating after deployment faces two failure modes:

• Divergence: under continuous updates, weights or state grow without bound and the system becomes unstable.
• Catastrophic forgetting: new updates overwrite the representations that encoded earlier skills.

The industry freezes models because of the first. The continual-learning literature exists because of the second: Oja-style normalization, EWC-style anchoring, neuromodulation, replay. Those tools work; each buys safety by trading memory, durability, adaptability, or compute. Freezing trades the dilemma away by giving up plasticity entirely.

A cold technical read of the constraints usually ends the same way: prescribe the toolbox, treat forgetting as a feature, assume the weights will explode. That assumption is the trap. If the weights don’t run away, the toolbox isn’t required, and retention stops being something you purchase by damaging plasticity.

Edge AI ships frozen inference: Train, freeze the weights, flash the chip. On-device learning after deployment is the acknowledged frontier. The blocker is trust. An unbounded learner updating itself inside a control loop can’t be left unattended, so nobody ships it.

Remove the divergence risk and freezing stops being mandatory. Holding previous tasks without bolting on the toolbox is what makes that option worth taking.

State. The internal state stays in a fixed range under any input or weight value. Necessary, familiar, not the news.

Weights under continuous online learning. This is the non-obvious half. Live field updates stay in envelope; the system recovers when internal state is corrupted. Stability alone does not guarantee retention: a properly stable network on a shared multi-task stream can stay bounded and still shed earlier skills as it learns later ones.

Retention without the pathology. The catastrophic-forgetting failure mode that motivates the toolbox does not arise here. The network doesn’t have to shed prior tasks to keep learning. Capacity is still finite, and the limit is the ordinary kind, set by neuron count and by how much the stream revisits what it taught. It is not a property of the architecture forcing overwrite, and it is not a price you pay for staying live. Below that capacity, learning is additive; prior tasks are held, not overwritten to make room.

Because neither failure mode is structural here, the network updates its real weights, so adaptation persists. It needs no task boundaries. It doesn’t cannibalize old skills for new ones below capacity. The properties the toolbox sacrifices to buy safety are kept because the safety wasn’t purchased that way.

The usual menu has two items: frozen, or live and risky. This is a third. It learns live and label-free from what happens next on the device, with no teacher or cloud, and it’s bounded by construction, so live doesn’t mean unsafe. Learning and authority stay separate concerns: learning is opt-in, and if you want a harder gate, you can require a new policy to outperform the one in charge before it takes over.

Which also reframes what “safe” means. Freezing doesn’t preserve correctness. It preserves whatever happened to be true the day you froze, mistakes included. A frozen model on an asset that has since been rewired, reloaded, or repurposed isn’t neutral. It’s confidently wrong, indefinitely.

Properties and evidence are public; mechanism details are available on request.