NeoHorse-1-4B Hands-On Review: The Local Small Model That Trains Itself

Tech blogger Fahd Mirza recently demonstrated a rather unique open-source model on his channel — NeoHorse-1-4B. This model, with only about 4 billion parameters, is built on the Coin 3.5 framework and developed by the Token Rhythm team. Its real selling point isn't its architecture, but its training approach: it continuously improves itself by observing the decision-making process of a live routing system. This article, based on the original video demo, breaks down the model's core concept, real-world performance, and limitations.

Core Concept: Recursive Self-Improvement

What sets NeoHorse-1-4B apart from traditional models is that it doesn't improve by learning from static samples. Instead, it learns by observing how a live routing system operates.

Imagine this scenario: a router sits in front of a collection of different AI models, deciding in real time which model should handle which request. Every time it makes a decision, it quietly logs the details — what type of task it was, which model was selected, and whether the result was effective. These records are normally just routine operational logs, but NeoHorse's training approach transforms these real interaction records into training material.

Even more critical is the training sequence. This data is fed into the model in order of difficulty, allowing it to build up capabilities gradually — much like how humans learn a skill — rather than being thrown into hard problems right away. In the second phase of training, a more powerful teacher model observes NeoHorse attempting tasks in real time and provides corrections — with the emphasis on "in-the-moment correction" rather than simply presenting pre-written reference answers.

This creates a self-recursive loop: after the improved model is deployed, it generates new logs, which are then used to train the next version. It's worth noting that this recursion happens during the training phase, not during inference.

This training paradigm is closely related to the academic concept of Curriculum Learning — an idea proposed by Bengio et al. in 2009 — which holds that arranging training samples from easy to hard helps models converge more stably and avoids gradient chaos from encountering overly difficult samples too early. NeoHorse's approach can be seen as an engineering application of curriculum learning on real-world system logs.

The teacher model's real-time correction phase overlaps conceptually with Online Distillation and Process Reward Models (PRM). Unlike traditional knowledge distillation, which prepares soft labels in advance, the teacher model here provides feedback simultaneously as the student model reasons, supervising intermediate steps rather than just the final answer. This focus on "process" rather than "outcome" is believed to be more effective at cultivating the quality of a model's reasoning chain — a direction validated by recent research from both OpenAI and DeepMind.

Live Demo: Finding the Hidden Bug in a Glacial Flood Warning System

To test the model's real-world capabilities, the blogger built an application called GlacierWatch — a glacial flood warning system designed for six towns downstream in a valley. The system uses Docker to deploy frontend and backend components, including Redis caching and an actual database, pulling live data from the application for analysis and statistics.

The demo concealed a serious logic bug: even when simulating a dam breach, glacial melting, crevasse formation, and triggered alerts, the top of the system stubbornly displayed "No people in flood zone" with water levels at zero. The blogger pointed out that this is precisely the most dangerous type of bug in such systems — a false sense of safety.

He configured the model to run through the Hermes agent, giving it only a single goal: find and fix all the bugs on its own, without telling it how. The model ran locally in VLM mode, and the blogger also showed its VRAM usage (including KV cache).

During execution, this 4-billion-parameter model performed extensive recursive computation — repeatedly checking each endpoint and ultimately returning 200 results. After refreshing the page, the system correctly displayed over 41,000 people in the flood zone, the dam breach area was highlighted in yellow, and the red alert water level line appeared as expected. The blogger commented: "A model with only 4.1 billion parameters actually exceeded expectations." He did note that something strange happened during the recursive process — the model's chain of thought appeared to "drift," with what seemed to be Russian text appearing intermittently.

The Hermes agent framework mentioned in the demo is an agent orchestration layer that provides LLMs with tool-calling and multi-step planning capabilities. When running in agent mode, the model doesn't output an answer in a single pass — it repeatedly cycles through "think → call tool → observe result → think again" until the goal is achieved. This explains how a small 4-billion-parameter model managed to handle what seemed like a complex bug investigation: the actual "intelligence" is carried by multiple iterative loops, not a single inference pass.

The apparent Russian text that appeared during the demo may have originated from multilingual logs mixed into the training data, or it could be a "language drift" phenomenon occurring under heavy recursive reasoning pressure — something relatively more likely to surface in small-parameter models, whose attention mechanisms have inherently limited capacity for maintaining long-context consistency.

Benchmarks: Well-Rounded Performance at a Small Scale

The development team compared NeoHorse-1-4B against five similarly sized models (approximately 4 billion parameters).

The results show that across nearly every category — agent tasks, coding, instruction following, and more — this new model ranks at or near the top. The blogger specifically highlighted the rightmost number: the average score across all 10 benchmark tests. This average is meaningful because it demonstrates that the model doesn't only excel in one narrow area — its performance is consistently strong across the board.

The blogger summarized: NeoHorse didn't win by being the "biggest" model, but by having a distinctive training approach. This aligns well with its recursive self-improvement design philosophy.

Creative Writing Weakness: The Cost of Recursive Training

After the coding test, the blogger designed a very different creative writing task: using a reclusive immigrant as the protagonist, transforming mundane weekly materials — WhatsApp spam messages, electronic bills, and similar everyday noise — into a deep non-fiction piece exploring loneliness and connection in modern society.

The model's performance was mixed. Structurally and technically it was quite fluid, with several literary highlights — effective use of fragments, white space, ellipses, and even emoji design showed genuine craft. But the problems were clear: the narrator's identity was unstable throughout, shifting between mother, son, daughter, and grandchild, eventually blending them all into one confusing figure.

The blogger theorized that this is a side effect of recursive training — while the model gained strong coding and agent capabilities, it lost the linguistic fluency and consistency of the original Coin model. He put it plainly: "When it comes to creative writing, I think it still doesn't perform as well as that 4.1-billion-parameter Coin model."

The character identity confusion in creative writing corresponds technically to a degradation in Coreference Resolution capability. Recursive training heavily uses reward signals based on task completion rates and code execution results — signals that provide almost no explicit supervision over narrative-level constraints like "who is who." After prolonged fine-tuning under such signals, the model likely experiences forgetting in its general language modeling capabilities — consistent with what the continual learning field calls Catastrophic Forgetting: strengthening new capabilities often comes at the expense of older ones, and this effect is especially pronounced in small-parameter models.

Why It's Worth Watching

The value of NeoHorse-1-4B isn't that it's a perfect general-purpose model — it's that it demonstrates a different path to capability improvement: by observing real routing decision logs, training progressively by difficulty, having a teacher model provide real-time corrections, and ultimately forming a self-recursive improvement loop.

For developers focused on local deployment and agent-style tasks, its performance in coding and bug investigation is well worth trying. But if your core needs involve creative writing or scenarios requiring long-form consistency, careful evaluation is warranted. As the blogger said, everyone knows their own needs best — what this model can and cannot do ultimately needs to be explored in real-world use cases.