Blog
Practical, honest writing on tiny LLMs, ternary models, and on-device AI — every claim backed by the open repository.
Decision guide
A decision guide, not a sales page: which microcontroller runtime to pick, based on whether your classification window slides — with the measured numbers for both.
Engineering
A stateless runtime recomputes all 128 samples when only one changed. Delta inference computes one timestep per layer instead — 27.3× cheaper per decision, bit-identical results, and three boundaries where it stops working.
Practical
Weights are the small half. The runtime is often bigger: 8,400 bytes for a compiled engine against 38,912 for a TensorFlow Lite interpreter. A budgeting procedure you can run before training anything.
Explainer
Ternary is about 4× smaller than int8 and removes multiplication entirely — but it cannot be retrofitted to a trained model. Measured numbers on the same network and a straight answer on when each one is right.
Method
The five ways a small-model benchmark goes wrong — test-set selection, shuffled time series, under-trained baselines, hardcoded opponents, best-seed reporting — written as the mistakes we made, with the numbers they cost us.
Regulation
Record keeping, transparency, human oversight and robustness, translated into firmware: hash-chained logs, signatures bound to model bytes, a real abstention path, and why bit-exact parity turns an argument into a test.
Release
Atome LM v2 turns the tiny ternary engine into 11 applied on-device AI heads plus an on-device OS — agriculture, voice, motion, anomaly and more — running offline on any ESP32, signed and bit-exact.
Perspective
An open ternary language model from Tilelli Lab — a Morocco-rooted effort — that runs on a $5 microcontroller. Morocco isn't only AI consulting; it's shipping open LLMs and edge-AI products.
Application
A $5 ESP32 + a soil probe = an offline crop sensor that decides irrigation, frost-risk and pest conditions on-chip — trained on your own field, no cloud.
Milestone
No longer QEMU-only: the 944K model runs on a real ESP32-WROOM-32, fully offline, ~1 tok/s — with a prebuilt binary, a serial log and a one-command flash you can verify yourself. Honest scope: a proof of execution, not a benchmark win.
Edge AI
Most “tiny” LLMs need megabytes of RAM. Here is the real memory math for running a language model on an STM32, RP2040 or ESP32 — and what actually fits in 256 KB.
Comparison
A side-by-side comparison of TinyLlama, llama2.c, TinyMaix and Atome against real microcontroller RAM and flash budgets — with an honest verdict on what fits a $2 MCU.
Explainer
Ternary weights let a trained language model fit in flash. Here is what 1.58-bit BitNet quantization means, why it is fast on a microcontroller, and what it costs in accuracy.
Honest results
A two-directional benchmark of a ternary tiny LLM against a vanilla FP32 transformer: a clear 60K-parameter win, a clear 944K-parameter loss, and why the reversal matters.
Engineering
How a ternary language model runs on ESP32 and STM32 through a heap-free C99 engine — and why bit-exact Python-to-C parity matters for shipping edge AI you can trust.
Use cases
A grounded look at what a kilobyte-class on-device language model is genuinely good for — command parsing, anomaly flags, intent routing — and three things it cannot do.
Architecture
Why the Atome C engine allocates nothing at runtime, talks to nothing, and what a zero-heap, air-gapped language model buys you for privacy, security and reliability.
Hardware guide
A per-chip fit guide for running a language model on a microcontroller, using Atome's measured RAM and flash budgets across STM32, RP2040 and ESP32-S3.
Guide
Privacy, latency, cost and reliability trade-offs between running a language model on the device and calling a cloud API — a practical guide for embedded product teams.
Opinion
A five-point test for any “runs on the edge” LLM claim — RAM fit, flash fit, heap-free, reproducible, measured not estimated — applied honestly, including to Atome.