Atome LM is a language model small enough to compile into the firmware of a microcontroller. Not a model you call over an API. Not a model you shrink onto a phone. A model that ships inside the same flash image as the rest of your firmware, on a part that costs a couple of dollars and has no operating system, no network stack and no memory allocator.
The shipped 944K-parameter checkpoint is 271 KB of weights and the engine that runs it is 2.6 KB of compiled C99. Together they are smaller than a medium JPEG. On a physical ESP32-WROOM-32 it generates coherent English text at about 1.0 token per second, fully offline, with nothing but the chip and a USB cable.
What problem it actually solves
The interesting constraint on a microcontroller is almost never "can it think". It is "will it fit, and can I prove what it will do". Three things follow from that, and they are the whole design:
- Fit. A part with 128 KB of flash and 20 KB of SRAM does not run a quantized 1B model, no matter how good the quantizer is. It runs something that was designed for 20 KB of SRAM from the first line.
- Proof. A device that gets certified — medical, automotive, industrial — has to demonstrate that what was validated is what ships. A model whose Python reference and whose on-chip C engine produce byte-identical output makes that demonstration a test rather than an argument.
- Silence. No allocator, no sockets, no file handles. The absence of egress is a property of the binary, not a promise in a privacy policy.
What it is not
Being clear about this saves everyone time.
- It is not a chatbot. At 944K parameters, trained wide, it produces incoherent output. That is a capacity limit, not a bug and not something a better prompt fixes. It is coherent when it is trained narrow — one domain, one vocabulary, one job.
- It is not a compressed GPT. You cannot take a large model and quantize your way here. Ternary models are trained ternary from the start, with a straight-through estimator, so the network learns weights that survive being snapped to three levels.
- It does not win everywhere. At 60,000 parameters the routed-ternary block beats a parameter-matched FP32 transformer by about 22% on TinyStories perplexity. At 944,000 parameters the plain float model wins by about 11%. The bet is deliberately the sub-1M, microcontroller-class regime, and outside it we lose. That is on the limitations page, in full.
The two product lines
The name covers two related things, and confusing them makes the numbers meaningless.
| Atome LM (the language model) | Atome LM EDGE (the sensing engine) | |
|---|---|---|
| What it does | Generates and classifies text on-device | Classifies sensor windows on-device |
| Typical size | 60,000 – 944,000 parameters | ~6,567 parameters |
| Footprint | 20 KB – 271 KB of weights | 15,444 B total flash |
| Verified against | Cortex-M3 under QEMU, and a physical ESP32-WROOM-32 | 2,947 held-out windows through the real C engine |
| Public? | Yes — Apache-2.0 | Pilot engagement |
The TensorFlow Lite for Microcontrollers comparison is about the EDGE line. The perplexity numbers are about the language model. Mixing them is how you end up quoting a footprint from one and an accuracy from the other.
How it is built
Each block runs three structurally different operations in parallel — a 5-tap depthwise causal convolution, a diagonal state-space model and a top-k=4 sparse attention — and a per-token softmax router decides how much of each to use for the character in hand. Three small specialists cost less memory than one big generalist at the same quality, which is the whole reason the architecture earns its place at this scale. All projections are ternary, per-tensor scale. The architecture page takes that apart properly.
Where to go next
The three pathways and the router
Why three specialists and a switch beat one generalist at 20 KB of SRAM.
FitWhich microcontrollers it runs on
Measured RAM high-water per model size across STM32, RP2040 and ESP32.
Evidencevs TensorFlow Lite for Microcontrollers
Footprint 4.64×, streaming 27.3×, accuracy a tie, latency a loss.
ProofHow bit-exact parity is checked
Same words, byte for byte, across Python, C99 and emulated silicon.
Questions
What is Atome LM?
Atome LM is a ternary language model whose C99 engine compiles into the firmware of a microcontroller. The 944K-parameter checkpoint is 271 KB of weights plus a 2.6 KB engine, runs with no heap, no syscalls and no network, and generates coherent text on a physical ESP32-WROOM-32 at about 1.0 token per second.
Can a language model really run on a $2 microcontroller?
Yes, if it was designed for one. A 944K-parameter ternary model fits in 271 KB of flash and runs from a 2.6 KB engine with no dynamic memory. What does not work is taking a large model and quantizing it down — the capacity is not there and the runtime assumptions do not hold.
Is Atome LM open source?
The architecture, the C99 engine, the export format and a 944K TinyStories checkpoint are Apache-2.0 on GitHub, with the weights on Hugging Face and a citable Zenodo DOI. More elaborate internal variants and the EDGE benchmark harness are not public.
How is Atome LM different from BitNet or llama2.c?
BitNet b1.58 is ternary but starts at around 700M parameters and targets servers and phones. llama2.c compiles for microcontroller-class parts but keeps FP32 or int8 weights. TinyMaix and esp32-llm run roughly 15M-parameter models on an ESP32-S3 with PSRAM. Atome LM's combination is the narrow one: ternary weights, a zero-heap pure-C99 engine, and bit-exact parity verified under QEMU.