The Node That Keeps What It Learns
The learning engine inside HARTOS writes what it learns into its weights, on your machine, and still knows it tomorrow. Measured against fine-tuning and replay, with the numbers.
The Node That Keeps What It Learns
The Node That Keeps What It Learns
HevolveAI is the learning engine running inside your HARTOS node. It learns from that machine's own use while it is answering you, and it writes what it learns into its weights. It still knows tomorrow what you taught it today.
That last part is the whole point, and it is what a language model cannot do.
A model that reads vs a model that changes
Show a language model six examples and it will pick up the pattern. We measured this against a real 2B-parameter model running locally: its error fell from 0.860 to 0.020. That is real learning and we are not going to pretend otherwise.
Then the conversation ends, the context window scrolls, and it is gone. The weights never moved. Tomorrow the model meets you as a stranger.
HevolveAI learns in the weights, from a single example, during inference. What it learns survives the session, the restart, and every task learned after it.
Measured, not asserted
Every comparable approach we could run went through the identical protocol on the same 4-core CPU box with no GPU: learn task A, then learn a different task B, then check whether A survived and how much a single new example teaches.
| Approach | Keeps the old skill | Learns from one example |
|---|---|---|
| HevolveAI | 1.00x, no measurable loss | 100% |
| Transformer, fine-tuned | 5.95x worse | 24.2% |
| Plain network, fine-tuned | 59.7x worse | 9.2% |
| World model, with replay | 61.4x worse | 11.9% |
| Same, replay removed | 24,888x worse | 12.2% |
| Language model, in-context | weights never change | prompt only |
That last pair of rows is the interesting one. A replay-trained world model appears to remember, until you take away its replay buffer and it collapses by four orders of magnitude. Its memory was never a mechanism. It was re-training on hoarded data, forever, at a cost that grows with everything it has ever seen.
Why ours does not forget
New skills are written where they cannot overwrite old ones. Learning task B does not disturb task A, there is no buffer to keep and nothing to re-train, and the guarantee does not weaken as skills accumulate. Retention is a property of how the engine is built, not a chore it has to keep performing.
What it does on your machine
Several learning systems run at once and divide the work rather than duplicating it. One remembers a specific fact from a single exposure and recalls it exactly. Another learns, more gradually, how your particular environment behaves over time. Neither erodes the other, so the node can absorb a correction instantly and build a long-run model of your world at the same time.
It runs on a 4-core CPU with no GPU. On live traffic a single example cuts error by 91 to 97 percent. Five hundred learning events have been restored intact across restarts. Learning happens on the device, and nothing leaves unless you choose to share it.
It sizes itself to the hardware it finds. Memory scales to the free RAM on the node, capacity grows when new kinds of tasks arrive, and a small machine runs a compact configuration rather than being excluded. We developed it on a 4-core laptop with 2 to 3 GB free, because that is the floor that matters.
How it sits in HARTOS
HARTOS feeds it whatever that node can see: screen, camera, microphone, your corrections, the agents' own output. The learning happens on the device. Nothing leaves unless you choose to share a skill with your other machines, and what travels is the learned skill, not your raw data.
Because the world it learns is your node's world, the same engine specializes differently everywhere it runs: road behaviour in a vehicle, your workflow on a desktop, its own body on a robot. One engine, one learning law, a different accumulated world on every device.
HARTOS itself is open, Apache 2.0. The learning engine inside it is our own closed technology, shipped as a signed component. You get the capability and the measurements, not the internals, and whether that split is compatible with the rest of our argument is a question we keep in public: open problem 9.
What it is not, yet
Vision needs a vision-capable model present on the node, so small nodes run text-only today. We benchmarked a real local language model head to head, and hosted frontier models are not yet in that table. Learning shared across several machines is proven piece by piece, but not yet running live between two nodes in the field. And on a low-end CPU a learning event takes seconds, not milliseconds.
We would rather you see this list than discover it later. Everything above it is measured. Everything in it is work still in front of us.
All figures were measured on commodity hardware, a 4-core CPU with no GPU, under an identical protocol for every system compared. The replay-trained world model is our own compact implementation of that published architecture class, not a vendor release. The language-model figures come from a 2B open-weights model run locally.