Most AI is trained once in a data centre and frozen before it reaches you. HevolveAI keeps learning on your own machine, from what you allow it to see, and it keeps what it learns.
In one line: it predicts each next moment, learns from the gap between its guess and what really happened, and writes each new skill where it cannot overwrite the old ones.
How HevolveAI learns: the film
A large model is trained once, on data gathered before you ever met it, in a data centre you will never see. By the time it reaches you it is frozen. It can read what you put in front of it, but when the conversation ends nothing it saw has changed it. Tomorrow it meets you as a stranger.
Teaching it something new means training it again, and training on something new wears away what it knew before. Researchers call this catastrophic forgetting. The usual cure is to keep the old data and re-train on it forever, at a cost that grows with everything the model has ever seen.
Trained once, then frozen
HevolveAI runs one loop, all the time, in the background while Nunba keeps answering you.
1
Sense. It takes in what your node can see and hear: the screen, a camera, the microphone, your agents' replies and your corrections. Only the inputs you switch on.
2
Predict. Before the next moment arrives, it makes a guess about it.
3
Compare. Then reality arrives. The difference between its guess and what actually happened is the only teacher it needs.
4
Learn. It makes a small update right there, on your machine, and moves on to the next moment.
No labelled dataset, no answer sheet and no round trip to a data centre. On the home PC we measured, one learning event takes a median of 12.7 seconds, in the background.
The loop
Nobody writes the right answers down for it. The world supplies them, a moment later. When its guess was close there is little to learn. When the world surprised it the gap is large, and that is where it learns the most. Over time its guesses move toward reality and the gap shrinks.
Its guess moves toward reality
Some things should be learned at once. Tell it a door code and it should know it the next time you ask, not after a thousand repetitions. Other things only show up over time: when your days get busy, which app you open after which, how a room sounds in the evening.
HevolveAI does both. One part remembers a specific fact from a single exposure and recalls it exactly, across restarts. Another learns, more gradually, how your environment behaves. They divide the work instead of duplicating it, so neither erodes the other.
Two speeds
Each new skill is written where it cannot overwrite the old ones. Learning task B does not disturb task A, there is no store of old data to keep re-training on, and the guarantee does not weaken as skills pile up.
| System | Old skill after learning a new one | 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% |
Same protocol for every system on a 4-core CPU with no GPU: learn task A, learn task B, then measure A. Published July 2026. Method and caveats are in the write-up.
Nothing learned is lost
Every update is measured: how wrong its guess on that moment was before the update, and after. These figures come from the learning engine’s own counters on one home PC running Nunba, read on 10 October 2026.
6,745
learning events so far, each one in the background while Nunba keeps answering
93%
of measured updates did not make its guess on that moment worse. The other 213 of 3,011 did, and are counted.
81%
of 443 live check-points from 4 to 9 October, its own stated confidence out-predicted a fixed guess
The last figure matters as much as the other two. Before an update is checked, the engine says how likely its guess is to be good, and that statement is scored against what happened. A learner that cannot tell when it is likely to be wrong cannot be trusted with anything that matters.
It checks its own work
Every Nunba desktop install runs its own copy of the engine, and each one learns a different world: your workflow on a desktop, a robot’s own body, the road from a vehicle. When you choose to share, what travels between nodes is a learned skill, never your raw data.
The bar we hold the hive to is strict: the hive must beat every single node, on data none of them has seen. Today the pieces are proven one at a time, and the first live test between two nodes is next. The network’s own figures are on the hive census.
From one node to the hive
Learning between two nodes, live
The parts work separately. The test that would show two nodes together beating either one alone has not been run yet.
Speed
On a home CPU a learning event takes seconds, not milliseconds: a median of 12.7 s on the PC above. It runs in the background, so you never wait for it, but it limits how many moments are learned per minute.
Every update helping
7% of measured updates made its guess worse. We count them and publish the count.
Hosted frontier models
The benchmark compares systems we could run under one protocol on one machine. Hosted frontier models are not in that table yet.
Everything above this list is measured. Everything in it is work still in front of us.
Sources