Transient began on 2026-10-15 as a hunch and a small Rust program. Six days later it is a prototype with 92 passing tests, a public repository, and a long list of things it cannot do. This first post says what the hunch is, what has been built, what the results do and do not show, and what is next.
The hunch
Computers keep getting smaller. In the 1960s you rented a machine the size of a room; a phone now outperforms what flew to the Moon. Hardware will keep improving, but we have already run into ceilings in how current designs are implemented, and the software side has had far less attention than the silicon.
Most of today's large models descend from one design, the transformer of 2017. Since then the industry has mostly scaled it and refined it, with demand for GPUs and data-centre energy rising to match. Very little that is large has been started from scratch. If you were to rebuild from scratch and find a better implementation, the efficiency gain might not be an increment. It might be an iceberg.
That is a hunch, not a verified claim. It rests on judgement, not on what current research establishes, and there are good reasons it might be wrong: transformers win partly because they suit GPUs, and plenty of ideas that look good small fade at scale. We are following it anyway, for as long as it takes, and treating the difficulties as terrain to measure and not as reasons to stop.
What we decided
- Win differently, not bigger. We are not trying to out-scale cloud models. A personal system has advantages a provider cannot match by construction: it can spend unmetered time on a question, keep knowledge in storage instead of weights, learn from its owner privately, and work with no network.
- Learning is a design question, not an inherited pipeline. "Pretrain, post-train, freeze" is a convention. We want a system that keeps learning while it is used, and whose way of learning adapts too.
- Count joules. Parameters say how big something is. Operations, memory movement and energy say what it costs.
- Rust, from scratch, no dependencies, to keep every byte visible.
- Open. The code is AGPL-3.0-only, so that the work stays open and cannot be quietly closed behind a hosted service.
The first week
The first version was a 16,000-parameter network, written from scratch, that read a short query and answered with one word, along with a ledger that counts operations and memory traffic. Counting showed that about 91% of the estimated energy of answering was moving memory, not arithmetic. A plain fact store, with no training at all, kept learned lessons at roughly a nine-hundredth of the estimated energy of retraining.
From there each step came from a limitation of the last. Readers that ignore word position mattered more than any learning trick. A system that could say it did not know. Rules instead of tables, so that a sum fitted from examples held beyond the numbers it was taught, where memorising networks fell to 5%. Then the idea that mattered most: don't pick the learning method in advance. For each group of lessons, try several on facts held back, and keep the one that generalises.
That became baby: 13 groups of lessons, five mechanisms chosen per group by evidence, answers that say how they were known and refusals that say why. It found its own groups from 792 unlabelled lessons. It scaled to 600 groups and 25,776 lessons, where learning one more fact stayed at about half a millisecond. It tolerated a few percent of wrong lessons. It worked out 16 hidden numeric kinds nobody wrote a mechanism for, and asked a question when two explanations fit equally well.
A mistake worth telling
Careful, we found, is not the same as timid. A rule that fits everything it was taught can still change behaviour outside what it was taught: a sum that caps, or one that wraps around. Nothing in the lessons can reveal that, and the first prototype answered such questions confidently and wrongly, 53 wrong answers per run. So the default became careful: state a value as fact only inside the range taught or checked, and beyond it offer a labelled guess ("probably seven"), keeping a record of how often guesses at each distance turn out right.
Then we tested that, and it was wrong too. Two confirmed guesses at the edges of a range were being allowed to vouch for an unchecked corner between them: 4 wrong facts out of 9,309. The fix was to stop treating the reach as a box and treat it as a staircase, at a measured cost in coverage (unseen questions answered fell from about 97% to about 95% at 60 units). That pattern, build the harder test, find a new hole, fix it, write it down, has repeated every time. It is why the project's rule is not "never wrong" but never silently wrong. The full list is on the method page.
What the numbers do not show
Honestly: not as much as they appear to.
- Everything is a synthetic, tidy world: invented words, small numbers, a handful of phrasings. "0% wrong" is a spot check against hand-written must-refuse batteries, not a proof.
- The mechanisms, the expression language and the thresholds are ours. The prototype selects and builds inside them; it did not discover them.
- Energy is estimated from counted operations. Several big savings (answering fell from 8,977 operations to 57) come from an inefficient first design as the baseline.
- The prototype has never seen real text. It is not a language model, and nothing here shows that this kind of system can reach the quality of one.
What is next
- Real data. A harness for real text is built and tested on hand-written fixtures. The next step is to run it on a small public word-problem corpus. We expect it to refuse most of it; the reasons it refuses are the interesting result.
- A controlled comparison. A matched small transformer against
baby-style systems at several sizes, on quality at equal joules, retention after new learning, and how quickly each adapts to a correction. A rented GPU is planned for this, and the comparison model will be written in Rust so both sides are counted the same way. - Real joules. The CPU's own energy counter is readable now; it needs wiring into the ledger.
- Corrections that teach. Today one correction stops a wrong guess. It should also let the system learn the right behaviour from a few points.
Following along, and helping
TransientAI is one person for now, and there are no plans to change that for the core of the work. The repository is public and contributions are welcome: replications on other hardware, bug reports, and especially questions it should refuse but answers. The documentation shows how to build and run everything in a couple of minutes, offline. The progress page keeps the roadmap and the list of what we do not know.
Thanks for reading. We will report the next results here, including the ones that go badly.