minaiml
min ai ml — models on hardware you own
BROBOT is decision logic that has been executed and tested — and has never generated a token on a phone. It is not an installable release. Every figure on this page is a model or somebody else's published measurement, and is labelled as such. Work is private until it is released.
Created by codephreak for a more empathetic interaction: motion, vision, audio and participant interaction from a handheld anyone in the world already carries — and, docked into hardware through open drivers, walking. The model player is the first organ, not the whole animal. A language model never drives a motor: it proposes an intent, and a deterministic governor with a dead-man timer decides whether the body moves.
Open source or go away: anything without an OSI-approved licence is ignored — not linked, not benchmarked against, not used as a data source.
minaiml (say it minimal) is PYTHAI's delivery layer: the software that runs reasonable-sized models on hardware you already own. A mixture-of-experts model is mostly idle — a router wakes a handful of experts per token and leaves the rest on disk. Delivery is the art of exploiting that.
| device | model | tok/s | resident | engine |
|---|---|---|---|---|
| MacBook Pro M3 Max, 48 GB | Qwen3.5-397B-A17B | 4.36 | ~6 GB of 209 GB | flash-moe |
| iPhone 17 | Qwen3.5-35B-A3B | 11 | 1.4 GB of 13 GB | Flash-iOS |
| Raspberry Pi 5, 8 GB | DeepSeek-V4-Flash | — | — | flash-pi-dsv4 |
| 2-core CPU VPS, no GPU | mindXtrain39, 135M dense | 0.19 | — | Ollama |
The slowest row is ours, and it stays: a 135-million-parameter dense model runs three hundred times slower than a 397-billion-parameter sparse one. Sparsity, not size, decides what a small machine can run.
BROBOT — the build. minaiml/brobot is the model player itself, built from PocketPal AI (MIT, React Native + llama.rn). Its src/handheld/ module is the device side, and what it has found so far is the interesting part.
RAM is effort. Three things compete for it — weights, KV cache, prefill batch — and the KV cache is charged twice: once in memory, and again in bandwidth on every single token. So the configuration that fits the most context is reliably not the one that produces the most tokens.
| strategy | context | RAM | tok/s | tok/s per GB |
|---|---|---|---|---|
| speed | 1,024 | 2.17 GB | 7.6 | 3.51 |
| balanced (default) | 16,384 | 2.79 GB | 5.8 | 2.09 |
| context | 32,768 | 3.46 GB | 4.7 | 1.35 |
Maximising context returns 38 % of the tokens per gigabyte of the efficient point, and costs 38 % of the throughput to get there. So the player picks on that frontier instead of maximising any one axis, and it states what it rejected and why.
And the mixture-of-experts asymmetry, which is the whole argument in two rows: memory scales with total parameters, speed scales with active ones. On the same mid-range phone, a dense 35B holds 21 GB and runs at 0.7 tok/s; an MoE 35B-A3B holds the same 21 GB and runs at 6.5 tok/s — nine times the throughput at identical memory cost. Quantizing the KV cache turns out to buy speed as well as memory, and the gain grows with context: +12 % at 4k, +49 % at 32k.
Every number there is a model, not a benchmark, and says so — to be replaced by measured telemetry the moment a real device reports one. The specification is PLAYER.md; the reasoning that led to it is HYPOTHESIS.md.
Smart phones, plural. A phone at 11 tok/s is not a terminal for somebody else's data centre — it is a node. That reframes the problem: not "how large a model fits on this device", but "what does a mesh of small devices know together". The catalogue already carries the cluster layer — exo builds an AI cluster from everyday devices, distributed-llama splits one model across machines on a LAN, petals does it over a swarm.
The floor is two processors. mindX is the existence proof, and it is deliberately unglamorous: 2 CPU cores, 7.8 GB of RAM, no GPU, self-throttled to a third of the processor. On that it trains its own weights from its own memory — dreams become a corpus, the corpus trains a 135M actor, and a proof-of-recall gate decides whether the result is allowed to exist. It usually isn't: generation 39 is the newest the gate accepted, and every generation after it was refused. A gate that never refuses is not a gate.
That is the paradigm the phone inherits. CPU is the standing resource — always on, marginal cost zero, already in your pocket. GPU and rented capacity are episodic: you pay for a training event, then tear it down. So intelligence originates at the bottom and scales on demand, rather than living in one large machine somebody else owns. A thousand phones that each know a little, and can ask each other, is a different architecture from one model that knows everything.
Licence position. PYTHAI hosts no engine and no engine-derived artifact. The catalogue is a set of pinned references on GitHub, each carrying a FORK.json with its upstream, commit and licence — and four of them declare no licence upstream, which means all rights reserved by their authors. Those are read and cited, never redistributed, and nothing derived from them is published in this namespace. The register is LICENSES.md.
The catalogue lives on GitHub — github.com/minaiml: laptop engines, MoE streaming, phone and edge runtimes, browser targets, cluster inference, on-device speech and adaptation. Every fork carries a FORK.json recording upstream, the commit we pinned, the date and the licence — including the four that declare no licence upstream and are therefore never redistributed.
The models are at PYTHAI, licence-pinned at a commit: Qwen3.8 · GLM-5.3-Flash · Kimi K3 · Granite 4.2. Delivery software here, weights there.
Elsewhere: pythai.net · mindx.pythai.net · mindX, live. Built by Professor Codephreak.
Intelligence doesn't require a data center. It requires knowing which parameters are awake.