The dominant story about AI’s future is a story about size. Bigger models, bigger clusters, bigger datacenters, more electricity. The frontier moves forward by getting heavier. That story has produced real capability, and we are not arguing with the results. We are arguing with the assumption that it is the only road forward.
This note is our thesis, not our product. The earlier notes reported measured results from systems we have actually built and logged. This one looks past them, to where we believe those results lead.
The contrarian thesis
The conventional path treats intelligence as something that lives in a faraway datacenter, rented by the token, identical for everyone who queries it. A frozen model in the cloud cannot learn from you. It answers, it forgets, and the next person gets the same answer. The model you talk to tomorrow is the model you talked to today.
We believe the next leap is in the opposite direction: small models built on a different mathematical core than today’s chatbots — compute that grows in step with input length instead of ballooning with it (details under NDA) — that learn continuously, on the device, with the person using them. Not a smaller copy of the big model — a different kind of system, one whose defining trait is that it changes with use.
That belief is not a hope. It rests on three properties we have already shown, each in one of the prior notes: a small model can learn during a conversation, without retraining; it is light enough to live on a phone; and it can reason at a depth that the frontier models we tested do not reach. Those are the load-bearing facts under everything that follows.
A model that learns with you
Start with the most personal piece. In an earlier note we showed in-session adaptation: when a rule silently changes mid-task, a GoM brain recovers it in about 6 trials. Frontier models took roughly 28 to 30 trials, or never adjusted at all — a frozen model cannot update from feedback, by construction. We also showed one-shot memory recalling held-out facts at about 99 to 100 percent, versus roughly 17.5 percent when the base model recalls without the brain attached.
Put those together and you have the seed of something a rented cloud model cannot be: a model that actually accumulates you. It notices when the rules of your world change and adjusts, instead of repeating yesterday’s answer. It remembers what you told it once. And because the learning happens on the device, the thing it learns — your patterns, your corrections, your context — never has to leave it.
That last point matters as much as the capability. Personalization that lives in the cloud is personalization you have handed away. Personalization that lives on your phone is yours. Privacy stops being a setting you toggle and becomes a property of where the computation runs.
The swarm
One model that learns with one person is useful. A network of them is the interesting part.
Picture millions of these small models, each learning from its own user, on its own device. Each one is also connected — to larger GoM models in the cloud, and through them, to each other. In this design, the edge models learn the specifics of their person. The cloud models hold the shared knowledge. And the network carries distilled experience back and forth, so that what one model figures out lifts the others. The committee result in the reasoning note is this swarm in miniature: small models, together, beating what any one of them could do.
We have already seen the local version of this effect. In the note on learning, self-play lifted a GoM model on Sudoku-Extreme from 83 percent to 86 percent in a single run, with no retraining of any kind — a model improving itself from its own experience. Our roadmap is to make that compounding collective: a shared memory and a federated-learning loop where distilled lessons, not raw private data, move across the swarm. Every model that learns something useful would make the rest of the network a little better, without anyone surrendering what is theirs.
That is the part we mean by grows together. Not one model getting bigger in a datacenter, but a whole population getting smarter at once.
Edge and cloud, not edge versus cloud
None of this is a case against the cloud. It is a case for putting the right work in the right place.
The edge gives you three things the cloud structurally cannot: privacy, because the data stays on the device; latency, because there is no round trip; and personalization, because the model learning from you is the one in your hand. The cloud gives you scale and a shared base of knowledge that no single device could hold. The argument is not that one wins. It is that they are better together — the edge handling the personal, the immediate, and the private, the cloud handling the heavy and the shared, each doing what it is good at.
| Trait | Cloud-only model | Edge model in a GoM swarm |
|---|---|---|
| Learns from you | No — frozen, same for everyone | Yes — adapts on-device, with you |
| Your data | Leaves the device | Stays on the device |
| Latency | Network round trip | Local, no round trip |
| Marginal cost | Per-token pricing | $0 on-device |
| Shared knowledge | Yes | Yes — via the cloud tier (roadmap) |
The economics line up with the architecture. A GoM edge package is about 2.54 GB — a small base model plus a roughly 40 MB trainable brain — running at under 2 watts on-device, against roughly 39 GB for the best locally runnable model and hundred-GB-plus clusters in the cloud (third-party estimates). One checkpoint runs across Apple, NVIDIA, and AMD. On-device, the marginal cost of a query is zero. That is not a rounding error at the scale we are describing; it is the difference between intelligence you own and intelligence you rent.
Why this matters now
There is a macro reason to care about the direction, not just the elegance. Data centers already drove about half of all U.S. electricity-demand growth in 2025, and the IEA expects that to hold through 2030 (LBNL / DOE, 2024; IEA Electricity 2026). If the only way intelligence scales is by adding datacenters, that curve has to keep climbing.
An edge-native swarm bends the curve a different way. Work that runs at under 2 watts in your pocket is work that does not have to be provisioned, cooled, and powered in a building somewhere. The point is not to replace the datacenter — it is to stop sending it every small, personal, repetitive task that a model in your hand could do for free.
Why GoM, specifically
Plenty of people will tell you the future is small models on devices. The harder question is whether a small model can do the three things at once that this vision requires — and our answer is grounded in the prior notes, not in optimism.
It learns at inference: a brain that recovers a switched rule in about 6 trials and recalls facts after seeing them once. It is small enough for the edge: a ~40 MB brain that attaches to a frozen base of your choice, running today on TestFlight for iOS and macOS. And it reasons at depth: trained only on 3-to-8-disk Tower of Hanoi, GoM generalizes to 9, 10, 11, and 12 disks — 100-for-100 at both 11 and 12 — while every frontier model we tested drops to 0 percent at 11 disks and beyond. It exact-executes — the same input gives the same answer every time — and it declines rather than guesses when it is unsure. Those are exactly the properties a model needs if you are going to trust it to learn with you and coordinate with others.
The swarm is not built. But every piece it would be built from has been measured. That is the difference between a roadmap and a wish, and it is where we have chosen to build.
Roadmap and thesis. The forward-looking architecture in this note — federated, collective learning across an edge-and-cloud swarm — is W4M’s research direction, not a released product. Every quantitative result cited here is drawn from the measured notes earlier in this series, where the methodology and measured numbers are reported in full. Demos referenced across the series are real logged runs, not live sessions.