It learns while you use it

Almost every AI model you have ever used is frozen. Training ends, the weights are locked, and from that point on the model cannot learn anything new from talking to you. It can hold a conversation in its context window and seem to follow along, but the moment the session closes, whatever it figured out is gone. Tell it the rules changed, correct it ten times, hand it a fact it has never seen — none of that updates the model. It is doing a very good impression of learning without actually learning.

GoM is built the other way around. It is a graph of small specialized models plus a trainable “brain” of roughly 40 million parameters (~40 MB on disk) that attaches to a frozen base model of your choice. The base stays locked. The brain keeps adapting while you use it. This post is about what that buys you — measured, not promised.

Why a frozen model can’t get better on its own

The limitation is structural, not a tuning problem. A frozen large language model has no mechanism to revise itself between training runs. You can stuff examples into its prompt, and a strong model will pattern-match against them for a while. But it is not updating any internal state. When the conversation gets long enough that those examples scroll out of view, the behavior reverts.

The industry knows this, which is why a whole ecosystem of workarounds exists. Retrieval systems (RAG) bolt a searchable library onto the model. “Memory” features write notes about you and re-inject them into the prompt. Scratchpads and agent frameworks carry state from one step to the next. These are genuinely useful — and none of them are learning. They all do the same thing: change what the model reads, never what the model knows. The weights doing the reasoning are exactly what they were on training day, so the model’s competence never moves — miss the retrieval, overflow the context, or open a fresh session, and the “learned” behavior is gone. The one path that does change the weights, fine-tuning, is an offline batch process run back at the datacenter — not something that happens while you use it. Every one of these tools is a prosthetic around the same missing ability: the model cannot commit what it just experienced to what it knows.

The cleanest way to expose this is to change the rules mid-task without telling the model, and watch how long it takes to notice and adapt. A frozen model has only one move: keep applying the old rule until enough contradicting evidence happens to sit inside its context at once. Often that takes dozens of trials. Sometimes it never converges at all, because the model has no way to commit the correction to memory.

Six tries to catch a rule that quietly changed

We ran exactly that test. Partway through a task, we silently switched the rule the model was supposed to be following — no announcement, no flag, just a different correct answer from that point forward.

GoM recovers the new rule in about six trials. Tested frontier models (the largest commercial systems) take about 28 to 30 trials to adapt to the same switch — and a fully frozen model, with no way to update from the feedback it is getting, may never get there. The difference is not that GoM is a bigger model. It is that GoM can actually change in response to what just happened, and a frozen base, by construction, cannot.

This is the whole thesis of the series in one line. The interesting capability is not raw size — it is the ability to update at the moment of use, on the device, without a training pipeline in the loop.

It can improve its own solve rate by playing itself

Adapting to a corrected rule is one thing. Getting better at a task with no outside teacher at all is another. We took Sudoku-Extreme — the hard end of the puzzle distribution — and let GoM play against itself.

In a single self-play run, with no retraining and no gradient updates, the solve rate moved from 83% to 86%. Nothing about the underlying model changed on disk; what changes is the brain’s runtime state — its running beliefs and memory — not any weight on disk. There was no fine-tuning job, no labeled data, no human in the loop handing it the answers. The system generated its own practice, learned from how it went, and came out measurably stronger than it started.

Three points is not a headline number on its own. What matters is the mechanism: improvement that happens at inference time, from the system’s own experience, on hardware you already have. That is the kind of gain a frozen model simply cannot produce.

One-shot memory: see it once, recall it later

Continual learning also means remembering. Show a frozen model a new fact during a session and it will repeat it back while the fact is still in view — then forget it the instant the context window moves on. There is nowhere for the fact to go.

GoM holds onto it. On held-out facts shown exactly once, recall lands around 99 to 100%. The same facts read straight off the raw representations of a comparable frozen setup come back at about 17.5%. That gap — roughly 17.5% versus near-perfect — is the difference between a model that can form a durable memory from a single exposure and one that cannot retain anything past its context window.

The headline: reasoning bolted onto a frozen 8B

Here is the result that ties it together. We attached a roughly 40 MB brain to a frozen Qwen3-8B and measured grade-school math (GSM8K). The base model scores 9.5%. With the brain attached — and the base weights completely untouched — it scores 62.5%. That is a 53-point jump from a 40 MB addition, with no retraining of the 8-billion-parameter model underneath.

It generalizes across bases. On a frozen Gemma-3-1B, the same attachment cuts perplexity — a standard prediction-error score, lower is better — by 63.9%, a result replicated across three independent training runs (seeds). The base you choose stays exactly as it shipped; the brain is what carries the new capability. You are not paying to retrain a large model — you are adding a small, portable component that does the reasoning the base could not.

How does the brain know where to attach? GoM decides — automatically. For each frozen base and task, it searches the candidate layers of the model, measures where added reasoning helps most, and inserts the brain at that point. No hand-picking, no guessing. And the same automatic placement works whether the base is a dense transformer, a mixture-of-experts model, or a hybrid state-space design — from under a billion parameters up to thirty billion. The brain itself runs on a linear-time, non-attention core; the construction details sit under NDA, and this series stays on what the system does rather than how it is built.

The clearest test is a hard one. We pointed GoM at a frozen 30-billion-parameter NVIDIA Nemotron model — a hybrid mixture-of-experts design, roughly 750× the size of the brain. GoM chose the insertion point on its own (layer 33 of 52), trained the ~40 MB brain there, and lifted grade-school math from 38.7% to 60.7% — a 22-point gain, with all thirty billion base weights left untouched.

Thirty billion parameters. A 40 MB brain. Auto-placed. Automatic placement is what makes a result like that repeatable across models this different: the layer that helps most on an 8B dense model is not the one that helps most on a 30B hybrid MoE, and GoM finds each without a human in the loop. The 8B result is the headline; the 30B result is the breadth evidence — the same 40 MB brain, auto-placed, lifting a model nearly four times larger.

None of this requires a data center. The point of learning at the edge is that a small model on your own hardware can keep improving from use — adapting to changed rules, practicing against itself, remembering what it has seen, and reasoning above its weight class — all without a round trip to a cluster and without ever touching the base weights.

See it run

Methodology: all figures are from real, logged runs, not live or cherry-picked sessions. Rule-adaptation trial counts compare GoM against tested frontier models under the same silent rule switch; a fully frozen model has no update mechanism and may not converge. The Sudoku-Extreme 83→86% lift is a single self-play run with no retraining and no gradient updates. One-shot recall (~99–100% vs ~17.5%) is measured on held-out facts shown once. GSM8K 9.5%→62.5% is a ~40 MB brain on a frozen Qwen3-8B with base weights unchanged; the Gemma-3-1B −63.9% perplexity result is locked across three seeds. The frozen 30B NVIDIA Nemotron result (GSM8K 38.7%→60.7%, +22 points, auto-placed at layer 33, base weights frozen) is a matched-method evaluation over 150 held-out problems per arm (paired, p<0.0001). Numbers are reported as measured and are not extrapolated.