What is a self-training AI model?

Most language models stop learning the day they ship. Their weights, the billions of numbers that hold everything they know, are fixed when training ends. From then on a model can be prompted, wrapped in tools and handed documents to read, but the model itself learns nothing from any of it. To change what it knows, someone has to train a new version.

A self-training model is built to change that: it improves its own weights from data it produces or selects itself, instead of waiting for the next training run. This guide covers where the idea comes from, how it differs from the techniques it is often confused with, and what makes it hard. KTwo describes Crust 1 Beta as the first model in the world that trains itself natively, so we end with what that claim means and what to ask of it.

Why most models are frozen

Training a large model is a one-off, expensive event. A lab collects a dataset, runs pre-training for weeks on thousands of accelerators, post-trains the result (instruction tuning, preference tuning, safety work) and freezes it. The frozen model has a knowledge cutoff: it knows nothing about the world after its data was collected.

Freezing is a reasonable choice. A frozen model behaves the same way tomorrow as today, which makes it testable and predictable. But it has costs:

• It goes stale. Facts, products, laws and APIs change; the model doesn’t.
• It can’t learn from its own work. Every problem it solves, and every mistake it makes, is lost once the conversation ends.
• Updates come in big, slow jumps. Improvements arrive as new model versions, months apart, each one a fresh training run.

Most of the tricks used to work around this leave the weights alone and change what the model sees instead.

What “self-training” means

The term is older than language models. In machine learning, self-training classically means a semi-supervised loop: a model labels unlabeled data with its own predictions, keeps the labels it is most confident about, and trains on them. The idea goes back to the 1960s (Scudder, 1965) and became a standard technique in natural language processing with Yarowsky’s word-sense work in 1995. In 2019, Noisy Student ran the same loop at scale: a teacher network labeled 300 million unlabeled images, and an equal or larger student, deliberately noised during training, learned from them and set a new state of the art on ImageNet.

Language models made the loop more interesting, because they can generate the training data, not just label it:

• Self-Instruct (2022) had GPT-3 write its own instructions and answers, filtered out the invalid and near-duplicate ones, and fine-tuned the model on the rest.
• STaR, the Self-Taught Reasoner (2022), had a model write out its reasoning for many questions, kept the reasoning that led to correct answers, fine-tuned on it, and repeated.
• Self-Rewarding Language Models (2024) had the model act as its own judge, scoring its candidate answers and training on the preferences it produced, so that it got better at both answering and judging.

What these have in common: the model’s own output becomes its training signal, with a filter (correctness, confidence, a judge) deciding what is worth learning from. In most published work this happens in rounds, run by researchers, between versions. A model that does it as part of how it works, after it ships, is the harder and rarer thing.

Self-training vs fine-tuning, RAG and memory

Four techniques get mixed up because they all make a model seem to know more. Only two of them change the weights.

Retrieval and memory are useful and cheap, but they are lookup, not learning: take the documents away and the model is exactly as it was. Fine-tuning is learning, but someone else decides what to learn, on the lab’s schedule. Self-training is the only one of the four in which the model improves itself.

What makes self-training hard

If self-training were easy, every model would do it. Three problems stand in the way.

Catastrophic forgetting

Neural networks trained on new data tend to overwrite what they learned before, a problem McCloskey and Cohen described in 1989. A model that keeps training on this week’s material can get worse at last month’s. Techniques such as elastic weight consolidation slow down changes to the weights that matter most for earlier tasks, but keeping old skills while learning new ones remains the central problem of continual learning.

Model collapse

Training on your own output is a feedback loop, and feedback loops can run away. A 2024 paper in Nature, AI models collapse when trained on recursively generated data, showed that models trained generation after generation on model-made text lose the rare parts of the original distribution and drift into repetitive output. The authors’ conclusion wasn’t that self-generated data is unusable, but that what goes back into training has to be filtered seriously.

Evaluation and trust

A frozen model can be tested once and released. A model that changes has to be tested continuously: did today’s update improve the skill it targeted, did it break anything else, did it learn anything it shouldn’t have? Every self-training system has to answer what it learns from, who checks it, and how a bad update is rolled back.

What “trains itself natively” means for Crust 1 Beta

KTwo’s description of Crust 1 Beta is short: a 9B model, multimodal from the start, and the first in the world that trains itself natively. As the home page puts it, most models stop learning the day they ship; Crust 1 keeps going.

The word doing the work is natively. The techniques above are mostly pipelines: procedures researchers run around a model, in rounds, between releases. The claim for Crust 1 Beta is that training itself is part of what the model is, not a procedure wrapped around it, in the same way that it is multimodal natively rather than through add-on encoders.

KTwo hasn’t published how Crust 1 Beta’s self-training works, and this post doesn’t speculate. What we can offer is the checklist we would apply to any model that says it learns after it ships, Crust 1 Beta included:

1. What does it learn from? Its own outputs, curated sources, user data or a mix, and with whose permission?
2. How is forgetting measured? Does it keep scores on old skills as it learns new ones?
3. What stops a feedback loop? Which filter decides what is worth training on?
4. How are changes checked and reversed? Is every update evaluated, and can a bad one be rolled back?

Crust 1 Beta is in private beta and not publicly available. If you want to put those questions to it yourself, you can request access.

Frequently asked questions

Is self-training the same as fine-tuning?

No. Both change a model’s weights, but in fine-tuning people choose a dataset and run a training job, usually before release. In self-training the model produces or selects its own training data, filtered by some check, and the training repeats as it works.

Is retrieval-augmented generation (RAG) a kind of self-training?

No. RAG pastes relevant documents into the prompt at request time. The model’s weights don’t change, so it hasn’t learned anything: remove the documents and its answers go back to what they were.

What is catastrophic forgetting?

The tendency of a neural network to lose earlier skills when it is trained on new data. It is the main obstacle for any model that keeps learning after release.

What is model collapse?

The degradation that happens when models are trained repeatedly on model-generated data without enough filtering: rare knowledge disappears first, and output becomes repetitive.

Can I try KTwo Crust 1 Beta?

Crust 1 Beta is in private beta, by invitation, and not publicly available. You can request access, though a request doesn’t guarantee a seat. Its spec is on the model page.