NeoHorse-1-4B trains on live router decision logs instead of static datasets. Here's how its recursive self-improvement loop actually works.
What is recursive self-improvement training? #
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. NeoHorse-1-4B, a 4 billion parameter model from Token Rhythm built on top of Qwen 3.5, is a concrete example: it was trained on logs generated by a router system that decides which AI model should handle which incoming task, then refined by a stronger teacher model correcting its attempts in real time. The result feeds back into the next training round, creating a loop rather than a one-time training pass.
TL;DR #
- NeoHorse-1-4B is a 4 billion parameter model built on Qwen 3.5 that is notable not for its architecture but for how it was trained.
- The core data source is a router decision log , a record of which model got picked for which task and whether that choice actually worked.
- Training data is ordered easy to hard , so the model builds up capability gradually instead of being trained on a random mix of difficulty levels.
- A teacher model watches NeoHorse attempt tasks live and corrects it in the moment, rather than just supplying pre-written correct answers.
- The improved model goes back into service, generates new interaction logs, and those logs become training data for the next version , closing the loop.
- In a hands-on test, the model found and fixed a genuine “false all clear” bug in a locally running dashboard app using an agent setup, without being told where the bug was.
- On a creative writing test, the model showed strong technical fluency but lost narrative consistency , drifting between countries, languages, and family relationships within the same piece.
Other agents ship a demo. Remy ships an app. #
Real backend. Real database. Real auth. Real plumbing. Remy has it all.
How does the router-log training method actually work? #
Most AI systems that route requests to different models keep some kind of operational log by default. Every time the router makes a call, it records what kind of task came in, which model got assigned to it, and whether that assignment produced a good outcome. Normally this data just sits there for monitoring or debugging.
NeoHorse’s training approach treats that log as a training resource. The reasoning is straightforward: a router log is essentially a record of real tasks paired with real outcomes, which is closer to how the model will actually be used than a static, hand-curated dataset. Instead of training on examples written in advance by humans, the model trains on interactions that already happened in production.
The data is then sequenced from easy to hard. Rather than throwing the model into difficult tasks immediately, the training process ramps up complexity gradually, similar to how a person builds a skill through progressively harder practice rather than being handed the hardest problem first.
What role does the teacher model play? #
Once the base pass on router logs is complete, a second stage brings in a stronger teacher model. Instead of just supplying correct answers for the model to memorize, the teacher watches NeoHorse attempt tasks live and corrects it in the moment. This is a meaningful distinction: static correction (showing a model the right answer after the fact) teaches pattern matching, while live correction during an attempt teaches the model to adjust mid-process, closer to how a mentor corrects a student while they’re working through a problem rather than after they’ve already submitted it.
Why is this “recursive”? #
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 new logs then become the training material for the next version of the model.
That’s the recursive part: the system’s own operation becomes the fuel for its next training cycle. It’s worth being precise about where this recursion currently happens. According to the training approach described for NeoHorse, the self-improvement loop operates during training, not during inference. The model isn’t rewriting itself while answering your query in real time. It’s a training methodology where each generation of the model is shaped by logs generated from the previous generation’s deployment.
Does the training method show up in real-world performance? #
In a hands-on coding test, NeoHorse-1-4B was pointed at a locally running application, a glacial flood early warning dashboard tracking six towns downstream of a monitored glacier. The app had a subtle but serious bug: when a simulated glacier breach occurred and towns were shown to be flooding in the detailed view, a summary panel at the top of the app still reported zero people in the inundation zone and zero levees over topped. That’s a “false all clear,” the kind of bug that looks fine at a glance while the underlying reality is dangerous.
Everyone else built a construction worker.
We built the contractor.
One file at a time.
UI, API, database, deploy.
The model was given a single instruction, to find and fix every bug, without being told what the bug was or where it lived. Running locally through vLLM, the model went through an extended reasoning process, checking multiple endpoints, rejecting some of its own conclusions, and recursing through the checks repeatedly before settling on a fix. After the fix was applied, refreshing the app showed the corrected numbers: over 41,000 people correctly flagged in the inundation zone, with levee status and town-by-town risk displayed accurately.
For a 4 billion parameter model, that’s a meaningfully long and self-correcting reasoning chain, and the outcome (finding an unlabeled logic bug in a full-stack app) is a nontrivial coding result.
Is NeoHorse-1-4B good at everything, or just coding? #
Not everything, based on direct testing. On a creative writing prompt asking the model to turn a week’s worth of mundane WhatsApp messages, spam, and bills into a profound non-fiction piece about an immigrant’s loneliness, the output was structurally strong. It used fragmented sentences, white space, ellipses, and other literary techniques competently, and it stayed fluent throughout.
But it struggled with consistency. The piece never settled on a single country, language, or family structure. Characters described as mother, son, daughter, and grandchild blurred into what read like the same person across different passages. That’s a meaningful weakness for long-form creative writing, where narrative coherence matters as much as sentence-level fluency.
The takeaway from testing both domains: NeoHorse-1-4B appears to punch above its weight class specifically on agentic and coding tasks, the kind of structured, verifiable work that resembles what a router-log training process would emphasize (real tasks, real outcomes, correctable mid-attempt). Creative writing, which depends more on sustained internal consistency over a long output, showed cracks that benchmark scores alone didn’t capture.
Is this training approach worth paying attention to? #
For anyone building with small models, the interesting part isn’t the benchmark ranking, it’s the training philosophy. A model that learns from logs of its own real-world routing decisions, rather than purely from static curated datasets, is trained on data that’s inherently tied to actual usage patterns and actual success or failure. Combined with live teacher correction instead of static answer keys, that’s a different recipe than the standard supervised fine-tuning plus RLHF pipeline most small models go through. Whether it generalizes better in the long run is an open question. The single coding demonstration was strong. The creative writing test showed the approach isn’t a universal fix for consistency or narrow domain weaknesses. It’s a training method worth understanding, not a guarantee of uniform excellence across every task type.
Frequently Asked Questions #
What makes NeoHorse-1-4B different from other small models?
It’s not the architecture, which is built on the existing Qwen 3.5 base. It’s the training data source: real router decision logs and live teacher-model corrections, fed back recursively across model generations, rather than a static dataset trained once.
Does NeoHorse improve itself while running (at inference time)?
No. Based on the described methodology, the recursive loop happens during training between model versions, not while the model is actively answering a query. The model that’s running today was shaped by logs from a previous version’s deployment, not by rewriting itself mid-conversation.
Is NeoHorse-1-4B good at creative writing?
It showed strong technical fluency and used literary techniques competently in testing, but struggled with consistency, drifting between different countries, languages, and family relationships within a single piece. It performed noticeably better on coding and agentic tasks.
How large is NeoHorse-1-4B and what does it run on?
It’s a 4 billion parameter model, small enough to run locally, and was demonstrated running through vLLM with GPU acceleration in local testing.
What is a “router decision log” in this context?
It’s the operational record a routing system keeps when it assigns incoming tasks to different AI models, noting the task type, which model was chosen, and whether the outcome was successful. NeoHorse’s training process repurposes this record as training data rather than treating it purely as monitoring output.