W4M

A new architecture for machine intelligence

The next gains in AI come from changing the shape of the model, not the size of the cluster.

A new architecture that does what today’s frontier transformers demonstrably don’t. It reasons a billion steps deep, keeps learning after it ships, runs on a phone, and lets a fleet of devices pool everything they learn.

Read the Research Notes → Request access under NDA

Every claim below is a logged, reproducible run

What GoM does

GoM reasons
1.07B moves
A full 30-disk Tower of Hanoi solved move-for-move — all 1,073,741,823 moves, every one exactly optimal, verified inline, in ~9 minutes on a laptop CPU. Past 11 disks, every frontier model we tested scores 0%.
Thirty disks, zero errors →
GoM runs on the far edge
2.54 GB · < 2 W
Frontier-grade reasoning in a package that runs on a phone — roughly 15× smaller than the best model you can run locally, nothing ever leaving the device, $0 per query.
Reasoning at phone scale →
GoM shares learnings
45.6 → 100%
Split a task so each device sees only a third; after one overnight memory sync, every device scores 100% on the whole — including what only its peers saw (replicated ×3). Experience moves between units as a file.
The swarm, measured →
GoM learns without humans in the loop
87 → 100%
Left to practice against itself with zero human data, the continual-learning core took itself to a perfect score in four rounds — and lifted a stock LLM by +64 points through a 3 MB adapter, no retraining.
It sleeps, it remembers, it grows up →
GoM beats the field
4,865 / 4,865
A 400 KB, 98K-parameter model solves the hardest Sudoku tier outright — 100.00%, independently audited — and 98.7% in a single 0.2-second pass. About 1,000,000× smaller than a frontier model. (Kona: 96.2%.)
Sudoku’s hardest tier, solved →

Every W4M figure here is one logged run on a public benchmark, reproducible from the saved, unaltered model files — walked through in the Research Notes.

AI’s bottleneck has moved. The question is no longer whether a model can do the work — it’s what the work costs to run. Industry-wide, usage growth has outpaced per-token price declines, so the bills keep climbing even as each token gets cheaper. And the real ceiling is now physical: the power, cooling, water, memory, and capital that a data center consumes. You don’t get past that wall by building another data center — you get past it by using a new AI architecture, so the same reasoning runs on hardware you already own. For anyone whose roadmap is bounded by compute, power, or what can run off-cloud, the architecture itself becomes the lever.

What GoM is

GoM is an AI architecture built on a non-attention, energy-based core: it replaces the quadratic cost of attention with a linear-time mixing operator and spends a variable amount of computation per input — settling toward an answer and stopping once it has one. Alternatives to attention are now a crowded field. What’s different here is the combination — a single compact core that reasons at depth, learns from use without retraining, runs at the edge, and shares what it learns — not an efficiency gain alone. It is brain-inspired by design: cooperating modules, persistent memory, and the sense to stop computing once it has an answer.

One core, used two ways: a standalone reasoning core, validated from puzzle scale to a billion-parameter base; and a drop-in brain — a compact module that attaches to a frozen language model you already use and adds reasoning it lacked, with no retraining of the base.

Definitions, stated for scrutiny

Technical foundations

Two words get used loosely across the field. Here is exactly what we mean by each — and how we measure it.

Reasoning
Multi-step inference and long-horizon execution: reaching a correct final state through a long chain of dependent steps, where a single wrong step invalidates the result. We measure it where it cannot be faked — exact-match planning tasks whose optimal solutions run from hundreds to hundreds of millions of steps (Tower of Hanoi to 30 disks; the 17-clue Sudoku tier) — scored by exact match, not partial credit. Depth comes from decomposition and cross-checking: compact models proposing and verifying each other’s moves, and a subgoal system that segments a long horizon — not from a longer context window.
Self-learning
Continual adaptation after deployment, with no retraining and the base weights untouched. The system generates its own practice and improves from it (Sudoku self-play, 87% → 100%, no human labels); when a task’s rules change silently it detects the shift and re-learns in about six trials, where the frontier models we tested needed ~28–30 or never converged; and it consolidates what it learns on a nightly, spaced schedule. It is confidence-gated: a budget predictor that is right 96–98% of the time decides what the system can afford to attempt, so it declines rather than guesses when it is unsure.

Performance & efficiency

And yes — it scales, predictably

The architectural wins above are the headline. The scaling curve is the quiet insurance behind them: GoM follows a clean power law, so more capability is a budgeting exercise, not a research gamble.

irreducible loss ≈ 1.61 fitted 2.7605 · actual 2.7612 R² = 0.977 loss 5M tokens 50B (log scale)

A 962M GoM base follows a clean power law and lands on its own final loss to within ~0.03%. One identical recipe holds across a 32× ladder of model sizes (30M → 962M).

For the technical reader R² 0.977 across the logged run, 5M → 50B tokens. Early-fit extrapolation: fitted 2.7605 vs actual 2.7612. Five model sizes, 30M → 962M, sit on one power law (β = 0.245). Full fit methodology in the scaling note.

It is also repeatable and on-prem by construction: the same input yields a byte-identical answer where frontier models drift, and the model declines rather than inventing an answer when it is unsure — logic that runs entirely on hardware you control, with nothing sent to a server.

Built to deploy

Edge Brain
On-device reasoning
Runs at phone- and watch-class compute — offline, low-power, vendor-portable across Apple, NVIDIA, and AMD.
Inference Computer
A brain for any LLM
A compact module that drops onto any frozen language model and adds reasoning, memory, and tool-use — no base retraining, ~3% added inference compute.

We’re as clear about where GoM doesn’t win as where it does. It isn’t a chat model at this scale, and raw arithmetic isn’t its edge — its edge is doing more with fewer parameters, on cheaper hardware, with answers you can reproduce.

Each of these is one run deep in the Research Notes — the laptop win over Kona, a published state-of-the-art Sudoku solver; the reasoning lift on frozen 27B and 30B models from two different families; and the on-device head-to-head against Apple’s Siri.
Read the proof →

See the work.

The architecture, the benchmarks, the frozen checkpoints, and the technical paper are available to serious technical and strategic partners under NDA.

Research notes →