What “Mini-AGI” Actually Is
If you’ve seen the recent buzz around volotat/mini-AGI — a solo-developer project from Alexa Borski that went viral on Hacker News — you’ve probably heard the pitch: a byte-level language model that trains itself from scratch on a single 8 GB laptop GPU, grows its own expert sub-networks on disk, and claims to measurably reduce catastrophic forgetting. The name is doing a lot of heavy lifting, and the README itself opens with a blunt disclaimer: “Do not expect frontier-level capabilities.” This is not AGI. It’s not a downloadable chat model. It’s a toy-scale research experiment — and a genuinely interesting one.
Here’s what’s actually under the hood:
Byte-level tokenization. Instead of training a tokenizer, mini-AGI reads raw bytes — just 256 possible values plus a few special markers. No vocabulary to fit, no preprocessing step. It can theoretically ingest anything: code, chess notation, Wikipedia, arbitrary binary. The trade-off is efficiency: byte-level models need substantially more compute to extract the same signal that tokenized models get almost for free.
A recurrent transformer block with adaptive halting. Data passes through two dense “prelude” blocks, then hits a single recurrent block that can be applied up to 24 times per character. A “PonderNet-style” halting mechanism decides at each pass whether the model is confident enough to stop. Easy characters (a space after a common word) might halt after one pass. Ambiguous ones might loop 14+ times. The model learns where to spend its thinking budget.
Mixture of Experts with dynamic routing. At each pass, the model routes through just 8 of a larger pool of experts — small weight blocks — rather than activating the entire parameter set. There are no labeled “coding expert” or “chess expert”; routing is soft and learned, which means capabilities can interfere with each other through shared parameters. The README is upfront about this.
Disk paging — the headline trick. Every expert is a literal file on disk, and critically, each expert’s individual Adam optimizer state is saved alongside it. VRAM holds only the current working set: roughly 32 resident experts (~100M params) out of a total pool that, in the current public run, has grown to ~143 experts (~468M params). Total parameter count is bounded by free disk space, not GPU memory. That’s what makes the “8 GB laptop” claim possible at all.
The anti-forgetting claim. Borski fed the model 524,000 characters of nothing but chess, then measured damage across seven other subjects. Uniform learning rates caused classic catastrophic forgetting. Freezing unused experts didn’t help. But slowing the trunk learning rate — the shared embedding, attention, routing, and halting layers that every character passes through — to one-tenth the experts’ rate reduced cross-subject damage to within noise. It’s one probe, one subject swap, small data — not a proof. But it’s cheap, specific, and reproducible by anyone with a GPU.
Where it stands today. ~236.8M characters read. ~468M parameters. Held-out loss published across eight subjects (chess and stories strongest; Wikipedia and Chat Hermes weakest). Weights not released — only training code and sample logs. Output today: short, grammatically coherent, repetitive continuations. Not gibberish. Not a chatbot.
The Hacker News reaction split hard: “massive marketing overreach” on one side, “the first thing that looks like proto-AGI” on the other. A continual-learning researcher noted the absence of ablations and a formal algorithm description. Multiple commenters pointed out that the public training transcripts contain no coherent output yet, so the forgetting claim is essentially unverified by anyone other than the author. Borski’s own replies are notably non-defensive: he says plainly he’s not an academic, the model is undertrained, and the finding he stands behind is narrow.
What would change the verdict: released intermediate checkpoints, standard perplexity/ablation benchmarks, and independent reproduction by someone else on different hardware and data.
Why My Setup Couldn’t Run It
I decided to try it. Here’s what happened, honestly.
The hardware. An NVIDIA GeForce GT 1030 with 2 GB VRAM and ~1.1 TFLOPS fp32. The project’s stated minimum is 8 GB VRAM — a mid-range laptop chip like an RTX 3070. I was working with roughly a quarter of the required memory and perhaps 1/15th the compute.
The environment fight. My first attempt used Python 3.14, which has no PyTorch wheels for CUDA 12.4 — the version my NVIDIA driver (12040) supports. Installing PyTorch 2.14.0+cu130 gave the classic warning: “The NVIDIA driver on your system is too old.” The fix was to drop to Python 3.13 and install torch==2.6.0+cu124, which matched my driver. After that, torch.cuda.is_available() returned True and the device was detected. That part worked.
The corpus build. I ran python -m corpora all --limit 500, which downloaded seven lanes: Wikipedia, TinyStories, OpenHermes chat, OpenThoughts reasoning, arithmetic problems, Python source code, and chess games. Total: 259 MB, ~406M training tokens, ~4.1M held out. The self-knowledge lane produced nothing, which the README says can happen with the --limit cap. Not a problem.
The training start. The model initialized: 64 experts, 209.5M total parameters, 32 resident, 100.66M in VRAM. The disk paging design worked as advertised — the resident set is smaller than the full pool. Adam moments stored as bf16. Trunk learning at 0.1× the pool rate. All the clever architecture was there.
The wall. Training started. The GPU pegged at 99% utilization. VRAM climbed to 1,919 MiB out of 2,048 MiB — essentially zero headroom. After that: no loss values printed, no sample generated, no forward progress visible. The GPU was technically working as hard as it could, but the combination of a 2 GB card running a 100M-param working set plus Xorg plus Cinnamon plus everything else left no room for the model to actually move. I checked iostat — disk I/O was idle, so it wasn’t a data-loading problem. The CPU sat at 4–14% user, waiting on the GPU. It wasn’t crashed. It was just crawling at a speed that made “training” functionally equivalent to “frozen.”
The paging trick got the model to start. It didn’t get it to run.
What I’d Try Next
Three realistic options, in order of practicality.
1. Cloud GPU — the honest recommendation. Everything I did locally is reproducible on a rented RTX 3060 (12 GB) or T4 (16 GB) for roughly $0.20–0.40/hr on RunPod, Vast.ai, or Lambda Labs. The setup commands are identical to what I ran. A full training pass on a 686M-character corpus — days or weeks on the GT 1030 — becomes hours. For the price of a coffee, you get to actually watch the model learn instead of staring at a pegged GPU. This is the path I’ll take when I revisit the project.
2. Shrink the model locally. python3 train.py --help exposes flags for batch size, sequence length, layer count, and width. Crank them all to minimums. It will still be slow — the GT 1030’s memory bandwidth (~35 GB/s) is roughly a tenth of the 3070’s — but it might complete a step. Worth trying once, mostly for the experience of seeing it tick forward.
3. Read the code instead of running it. The interesting parts of mini-AGI are the paging logic (how experts and optimizer states are swapped between disk, RAM, and VRAM), the halting mechanism, and the trunk-vs-experts learning rate split. You can understand all of that from train.py, the model definition, and the README without training anything. For a researcher-curious reader, this is arguably the higher-value use of time.
The Takeaway
mini-AGI is not AGI. The name hurts it more than it helps — which is a shame, because underneath it are two genuinely checkable ideas: disk-paged experts that decouple model size from GPU memory, and a cheap, specific fix for one narrow flavor of catastrophic forgetting. Neither needed a grandiose name to be worth paying attention to.
What it isn’t, yet, is a model anyone can trust or verify. The weights aren’t published. The benchmarks are self-reported. The forgetting finding is one probe at small scale. It is, in the truest sense, an interesting demo — worth cloning, worth watching, worth trying yourself if you have the hardware. My hardware wasn’t enough, and that’s a real limitation of the project: for all the clever engineering around VRAM, 2 GB is still 2 GB.
The bar for taking it seriously is clear and fair: released checkpoints, standard benchmarks, independent reproduction. Until then, this sits squarely where most real progress sits — somewhere between skepticism and hype.