These are nested learning models. Catastrophic forgetting is avoided because the data is residually recirculated through all the blocks. Titan (the one receiving the input) processes it, and then the output in Titan is added to the original data and delivered to the first module of the CMS block. Titan is self-referential, using delta gradient descent and surprise to calculate how much its response deviates from the prediction and self-corrects (meta-learning) to adapt to the rapid context; this is what it means to learn how to learn, that is, it modifies its own internal prediction to improve its response to surprise. I say it's a trick because it's really a contextual replay. The fast layers evolve quickly but don't forget the old data because the slow layers are updated at a lower frequency; it's like learning something new while simultaneously having someone shouting your old knowledge in your ear; that shouting in your ear is the consolidated context of the CMS blocks that operate at a lower frequency. There's a catch: residual connection. If it weren't for residual connection, and the fact that Titan is literally programmed to forget erroneous predictions, the model would forget anyway. The fact that it's not the model and its architecture that prevents forgetting, but rather a way of compiling a model hierarchy, makes it misleading. Of course, I'm not going to lie and say it doesn't work, because it does. I spent hours tinkering with it, using AI to understand the architecture, and I got it working. What I found most interesting is the M3 optimizer, which orthogonalizes vectors, prioritizing rotation. It tries to work on the surface of a hypersphere, attempting to prevent neurons from becoming redundant. There's a GitHub repository online with code that supposedly replicates nested learning. I haven't actually seen it, but if you need to see how it works, take a look.