Guide: how SHADOW Assistant is built, and why
This guide explains the design behind the data in this repository: what the model is, how each kind of data is used, and the reason for every major choice. For where files are, see the README.
The model in one picture
text ── tokenizer ───────────┐
photo / video ── eye ────────┤ every input becomes 512-bit codes by one fixed rule
sound ── ear ────────────────┘ │
input adapter
│
body: 24 ternary layers = 21 RNN layers (fixed-size state) + 3 global attention layers
Engram: 4B n-gram memory rows on disk, text only
│
readout over the same frozen codes + a word-frequency prior
│
token
About 135M parameters in the body (about 30 MB at ternary), a 4B-row Engram (about 2 GB at int4, read from disk), and an eye and ear (EmbeddingGemma 2's vision and audio towers at int8) that load only when a picture or sound arrives.
The decisions, and why
One frozen code space for everything. Every token, picture patch and sound frame becomes a 512-bit code from EmbeddingGemma 2's space, and the token table is never trained. Our paper (Embeddings Are Overpriced?) showed a frozen table with a learned frequency prior beats a learned table. Because the space never moves, words, pictures and sound stay aligned for good: no connector is needed between them, a model trained on text alone can already read picture codes it has never seen, and new words can be added later. The table is 16.8 MB.
A ternary body. Weights are -1, 0 or +1 (BitNet b1.58), activations int8. The body is about 30 MB and fast on any CPU, and in our tests it learns as well as needed at this size.
An Engram. A large table of 2- and 3-token memories, hashed, read from disk a few rows per token. It stores facts and phrases cheaply, so the small body can spend itself on reasoning. It reads text only, never picture or sound codes.
Mostly RNN layers, three attention layers. 21 RNN layers keep a fixed-size state whatever the length, and only 3 global attention layers keep keys and values. Writing speed on a laptop CPU barely drops with context (551 tokens a second empty, 440 at 12k, 141 at 128k), the memory for the window stays small, and the RNN state (26 KB) can be saved to resume a conversation instantly.
Train exactly as it runs. Keys and values are stored at int4 on the CPU, so training uses int4 too. What the model learns is exactly what it runs.
Memory in four parts. A small model cannot hold a long conversation or a library in its weights, so SHADOW splits memory by job:
- The gist. The 21 RNN layers each carry a fixed-size state that is updated with every token. Together it is about 26 KB, the same after ten words or a whole book: a running summary of who, what and why. It is not exact, but it never grows, and saving it to disk lets a conversation resume in milliseconds without reading anything again.
- The window. The 3 global attention layers see the last 32k tokens exactly, with keys and values stored at int4. This is where precise wording, numbers and recent turns live.
- The archive and the index. When text leaves the window it is written to disk once, in 64-token blocks: the token ids plus the int4 keys and values of the 3 attention layers (about 0.8 KB per token). When a question arrives, a word-match search over the archive finds candidate blocks, and a small trained index reranks them by meaning. The best 2,048 tokens are loaded straight back into the attention layers, placed just before the question with the best block last, so the model reads them as if they had just been said. The gist is not touched by a fetch. The index learns from where the attention layers actually look, and from practice: during training, facts are placed early in long documents and asked about later, after they have left the window. In a test on a model trained on 0.85B tokens, fetching lifted recall of facts read about 1,400 tokens earlier from 9% to 63% of digits.
- The Engram. About 4B small rows, each tied to a hashed 2- or 3-token phrase, read from disk a few per token. It stores common facts and phrasing cheaply, so the small body can spend itself on reasoning. It reads text only.
Each part is taught by different data: long documents teach the gist and the window, archive practice teaches the index, and all the text fills the Engram.
All senses trained together. Text, pictures, video and sound go into one body in one run, rather than attaching vision to a finished text model. Caption text (about 10B tokens) describes physical, everyday scenes, which is exactly what small models lack.
Australia. About 34B tokens of Australian text (web, law, Parliament, biography, Wikipedia), Australian speech, Australian photos of plants and animals, and Australian everyday conversations, on top of a strong global base.
Context. Trained natively to 32k tokens; we have about 6.6B tokens in documents of 32k or more. Extension to 128k uses YaRN at run time and will be published with its test results.
Tuning after pretraining. Tuning teaches the model to answer, not what to know, so it always comes after pretraining. The picture, video and sound tuning mix follows SmolVLM's published findings: a separate text share, very little chain-of-thought, and loss on answers only.
Clean evaluation. Benchmark test data is kept out or listed (see the README). Every published number comes from a measurement.
How the data is used in training
| stage | data |
|---|---|
| Pretraining | all text, pictures, video and audio (without held-out shards and skip-listed items), windows growing from 2k to 32k |
| End of pretraining (anneal) | the 32k stage: about 40% long documents, 60% anneal maths, code and the best text |
| Tuning | text sets, then pictures, video, sound and text together, then the Australian conversations |
Sizes and speeds quoted here
All measured: CPU speeds on an Intel Xeon W-11955M laptop (8 threads) with our kernels at the real sizes; recall from a full-size test run on 0.85B tokens. Quality numbers for the trained model will be published with it.