Most AI models are trained once, on a dataset assembled before they exist, and then frozen. That default is starting to crack. Recursive learning: also called recursive self-improvement training, is a method where a model learns from records of its own real-world usage instead of a fixed, pre-built dataset. The system's operation becomes the fuel for its own next training cycle.
The clearest worked example we have seen is NeoHorse-1-4B: a 4-billion-parameter model built by Token Rhythm on top of Qwen 3.5, and the subject of a sharp hands-on writeup from MindStudio. NeoHorse is not interesting because of its architecture, the base is off the shelf. It is interesting because of where its training data came from. Here is how the loop works, and what it actually delivers.
The training data is the system's own history
Any system that routes incoming tasks to different models keeps an operational log by default: what kind of task arrived, which model got it, and whether the outcome was any good. In most deployments that log is monitoring output, it sits in a dashboard until someone goes looking for a problem.
NeoHorse's training treats that log as the dataset. The reasoning is sound: a router log is essentially real tasks paired with real outcomes, which is much closer to how the model will actually be used than examples written in advance by humans. The sequencing matters too. Rather than mixing difficulties at random, the training data is ordered easy to hard, so the model builds capability gradually instead of being thrown into the deep end on step one, the same reason you do not hand a new hire the gnarliest production incident on their first day.
A teacher that corrects in the moment
The second stage brings in a stronger teacher model, but not in the usual way. Instead of supplying pre-written correct answers for NeoHorse to memorize, the teacher watches NeoHorse attempt tasks live and corrects it mid-attempt. The distinction is not cosmetic. Static correction, here is the right answer, study it, teaches pattern matching. Live correction during the attempt teaches adjustment, which is closer to a mentor steering you while you work through the problem than to a grader handing it back afterward.
Where the recursion actually happens
The loop closes when the improved model goes back into live service. As it operates, it generates new interaction logs, the same kind of router decision data that started the whole process. Those logs become the training material for the next version. Generation N of the model is shaped by the deployment of generation N-1.
It is worth being precise here, because this term gets hyped. Per the MindStudio writeup, the recursion happens during training, between versions: not while the model is answering your query. NeoHorse does not rewrite itself mid-conversation. What it does is closer to a company whose operational history continuously reshapes how it trains its next generation of staff. A real loop, but a training methodology, not a live self-editing brain.
Two tests, two different answers
Does the recipe show up in performance? In the writeup's coding test, NeoHorse was pointed at a locally running app, a glacial-flood early-warning dashboard tracking six towns, with a single instruction: find and fix every bug. Nobody told it what the bug was. The dashboard had a subtle, serious one: when a simulated glacier breach flooded the detailed town views, a summary panel at the top still reported zero people in the inundation zone. A false all clear, the kind of bug that looks fine at a glance while the underlying reality is on fire.
Running locally through vLLM, the model went through an extended reasoning chain: it checked multiple endpoints, rejected some of its own conclusions, and looped back through the checks before settling on a fix. After the patch, the summary panel correctly flagged over 41,000 people in the inundation zone, with levee and town-by-town risk matching the detailed views. For a 4-billion-parameter model, finding an unlabeled logic bug in a full-stack app, with a self-correcting chain along the way, is a genuinely strong agentic result.
The creative writing test went the other way. Given a prompt asking it to turn a week of mundane messages, spam, and bills into a profound non-fiction piece about an immigrant's loneliness, the model produced something structurally fluent, fragmented sentences, white space, ellipses, all the literary technique you could ask for. But it never settled on a single country, language, or family structure, and characters described as mother, son, daughter, and grandchild blurred into what read like the same person. Sentence-level polish, narrative-level drift.
Read together, the two tests are the tell. The model punches above its weight on structured, verifiable, correctable work: exactly what router-log training with live teacher correction emphasizes, and shows cracks where a task demands sustained internal consistency over a long output. Benchmarks alone captured neither result. Hands-on testing did.
Why we are watching this
For anyone deploying small models, the interesting shift is philosophical before it is technical. If your routing system's logs are a training asset rather than just monitoring output, the economics of your AI stack change: a 4B model that handles agentic tasks credibly is a 4B model you do not have to route to an expensive frontier API. Recursive learning, logs in, curriculum, live correction, loop closed, is the recipe that gets you there, and it is a different recipe than the standard fine-tune-plus-RLHF pipeline most small models go through.
The honest caveats: this is one writeup, with one strong coding demo and one weak writing demo, and whether the approach generalizes over many generations is an open question. Recursive learning is not a guarantee of uniform excellence, it is a training philosophy worth understanding before it lands in the tooling you already run.
If you are building with small models and want a routing and training pipeline that compounds instead of freezing, that is the kind of system we design and ship. Book a strategy call and tell us what you are running.