--- license: agpl-3.0 language: - en library_name: dam1 pipeline_tag: question-answering tags: - dam-word - llm - symbolic - reading-comprehension - safetensors - rust - webassembly --- # 🧠 DAM1 DAM1 is an LLM of a different design. You tell it things and ask it questions in English, as you do with any LLM. It reads English one word at a time into a tree of things, places and the relations between them, the world the words describe, and answers from that tree. Like any LLM it reads a context of tokens and predicts the next token, one at a time. Its tokens are steps, not pieces of text: grab a thing, drop it into a place, write a property, find what a question names, get the answer, work a number, until it chooses to continue to the next word. The steps are fixed operations of the engine; the network only chooses between them. What it knows is in the tree, where it can be read and changed, and not in the weights. The network learns only how to shape and read that memory. That is why it is small: it is not a transformer, it was not trained on a large corpus, and it does not write free text. These files hold 1,870,616 numbers, one network, and the permanent state the project's seeds make. It runs on a processor, and in a browser through WebAssembly, where the Datamine Network chat runs it with nothing sent to a server. ## 📊 How it compares Every model was asked the questions of the held-out lines of DAM1's curriculum, which no network was trained on: 2,673 for DAM1, and the 2,669 that existed when the others were run. Each item is a short text and one question about it. One rule scores every reply. The other models are also given an order and two worked examples, which DAM1 is not; they run in float16 on an NVIDIA RTX 3080 Ti, DAM1 on the processor. | Model | Parameters | Weights | Memory | Answered | Exact | One answer | |---|---:|---:|---:|---:|---:|---:| | **DAM1** | **1,870,616** | **8 MB** | **23 MB** | **99.9%** | **99.9%** | **2 ms** | | Qwen2.5-0.5B-Instruct | 494,032,768 | 988 MB | 1.01 GB | 63.8% | 39.6% | 109 ms | | Qwen3-0.6B | 596,049,920 | 1.50 GB | 1.22 GB | 52.7% | 41.4% | 80 ms | | LFM2-350M | 354,483,968 | 709 MB | 727 MB | 52.2% | 44.1% | 53 ms | | SmolLM2-360M-Instruct | 361,821,120 | 724 MB | 760 MB | 51.4% | 34.1% | 114 ms | | SmolLM2-135M-Instruct | 134,515,008 | 269 MB | 285 MB | 36.0% | 14.5% | 228 ms | **Weights** is the file the hub publishes. DAM1's page downloads the same network written small, 3.3 MB. **Memory** is what answering one question takes: for DAM1 the one block of WebAssembly memory that holds the network, the state, the tree and the stack; for the others the most the card held over the same questions. **Answered** is the share of replies that say the answer. **Exact** is the share that begin with the answer and put nothing before it. **One answer** is the middle wait for a single question, for DAM1 on the processor and for the others on the card. The item set is DAM1's own curriculum. The words, the names and the numbers of a held-out line are new, but its sentence shapes are shapes DAM1 was taught, so this measures reading of a taught shape and not general knowledge. Ask about the capital of Peru and these models answer while DAM1 does not. The harness is in [benchmarks/](https://github.com/Datamine-Crypto/DAM1/blob/main/benchmarks/README.md). ## 📋 Model details - **Made by:** Datamine Network Inc. - **Model type:** an LLM built as a reader of one word at a time over a tree, driven by networks over a stack: an embedding per feature place, a block of weights per stack slot, one hidden layer of rectified units, an output per step class and a pointer over the words of the sentence. One network, trained from nothing; there is no base model. - **Language:** English. - **Licence:** AGPL-3.0-or-later. - **Files built at:** the commit `config.json` records under `build`, which the publish writes as it exports. - **Layout:** version 5, described in [FORMAT.md](https://github.com/Datamine-Crypto/DAM1/blob/main/huggingface/FORMAT.md). - **Source:** https://github.com/Datamine-Crypto/DAM1 ## ✨ What it does Tell it statements and ask it questions, across the turns of a conversation. It also knows what its seeds state: the number words, the measures, the clock, verb forms, opposites, what common things are and the like. These replies were said by these files with `dam1 talk`, each group one conversation. A statement is answered with nothing; the reply comes at the question. | You say | DAM1 says | |---|---| | tom has a red car. | | | who has the car? | tom | | what color is tom's car? | red | | what is 12 * 3? | 36 | | what is the opposite of hot? | cold | | how many legs does a dog have? | 4 | | the cat is in the box. the box is in the garden. | | | where is the cat? | box | | is the cat in the garden? | yes | | john took the ball. john went to the hall. | | | what is john carrying? | ball | | where is the ball? | hall | | ann has 3 apples. ben has 5 apples. | | | how many apples do they have together? | 8 | | who has more apples? | ben | | sam is taller than ann. ann is taller than bob. | | | who is the tallest? | sam | | is bob taller than sam? | no | | my sister lives in paris and she loves music. | | | where does my sister live? | paris | | what does she love? | music | It gets things wrong too, and a wrong reply looks the same as a right one: | You say | DAM1 says | Should be | |---|---|---| | there is a red box and a blue box. the red box is heavy. which box is heavy? | yes | the red box | | tom turned on the lamp. is the lamp on? | no | yes | | it rained all night. what happened last night? | (no reply) | it rained | ## 🎯 Uses Intended uses: - Research on reading into a tree with learned steps, as an alternative to a transformer. - Short conversations in simple English about things the user tells it: who has what, where things are, qualities, counts, sums, measures and time. - Running an LLM with no server and no graphics card: native or in a browser. Out of scope: - Any decision where a wrong answer causes harm: medical, legal, financial, safety or personal. - A source of truth. It does not know when it is wrong. - Free text generation, translation, summaries, or English outside the shapes its lessons taught. - Languages other than English. ## ⚙️ How it works 1. Text is split into sentences, and a sentence into words, numbers and marks. There is no learned tokenizer. 2. Memory is one tree, and the tree is a space: a thing is a node that stands inside its place or its owner, a relation is a braced token such as `{is}` or `{has}`, a count or a time is a tag on the thing, and a mention of a thing told before is a link to the same node. 3. Each word is one input. A word that names a thing makes the thing appear, the known one of its name or a new one carrying the flags the words before it set, such as `the` or a count. 4. The stack holds one sentence: the cursor, each word heard, and two events for every step taken (the step, and what it found or made). It is emptied at the next sentence. Each event is a set of features hashed into a space of 2^64 places. 5. A network reads the stack, one event per slot of 200. An event's embedding is the sum of the 16-wide embeddings of its places. Each slot has its own weights into 512 hidden rectified units. The outputs take a softmax over the 104 step classes. A class is a move and its properties, such as `{grab}`, `{drop @}`, `{children add: @ type: property}` or `{get owner}`. 6. The step with the largest share is taken. When the step takes a word of the sentence (the `@`), the pointers score every word on the stack the same way and the best one is taken. 7. The step runs, its two events join the stack, and the network chooses again. `{continue}` goes on to the next word. A word may take at most 50 steps. 8. What a sentence wrote to the tree stays for the next sentence and the next turn, so a question is answered from everything the conversation said and from the seeds. No rule decides an answer at reading time. Every step of every reading is the networks' choice. ## 🏋️ Training ### 📚 Data All training data is in the source repository, written for this project in plain English. None of it is a Hugging Face dataset, so the card lists no `datasets`. - `model/data/train`: 274 lesson files in 16 folders, from basics and Grade 1 to Grade 12 and university, with the world lessons and the debug cases agreed while the design was made. Each line is text with the shape its tree should take and the answers expected. A line is either learned or held out of training: 2,575 learned lines and 942 held-out lines. The 12 debug cases are graded and never trained on. - `model/data/facts` and `model/data/seeds`: plain fact sentences and the 60 seeds files built from them, told into the tree before anything is read. They are not used to train the network. They make the state every lesson and every chat starts from, which ships as `state.bin`. #### What the lessons teach One concept a file, from the basics up to a university exam: - **Basics:** simple statements and questions, places, changes over time, referring back, yes and no, adjectives, searching the tree, which one, partial views and partial searches, checking again, tricks, conclusions, actions, hidden things, conversation. - **Grade 1:** scenes with several things and owners, counts, forms of having, not having, decomposition. - **Grade 2:** places, time and owning, possessives, classes, days, greetings, indirect questions, negatives, have questions, our and their, family, animals and their sounds, shapes and sides, weather and seasons, a and an, plural counts, my things, them, whose, letters and vowels, changing hands, two things alike, about me, stronger and weaker qualities, going to, story openers, colored things, things that happen, another one, labels and traits, always and never, how much. - **Grade 3:** arithmetic in words, the number after, between, counting between, successors, odd and even, tens and hundreds, place value, greater and less, more and fewer, the biggest number, totals, counts over two owners, the next season, day, month and letter, alphabetical order, ordinal days, order and time words, order in a line, carrying a sum on, numbered ones, part of a group, on and off, my pocket. - **Grade 4:** tell me about, comparisons and their inverses, qualities and opposites, verbs and their objects, seeing, giving, moving and carrying, picking up and dropping, what was carried before, counting what is carried, before and after, they, earlier and later, longer and heavier, hotter and colder, the passive, relation words, that clauses, can do, lost things, done by, because, telling, kin somewhere. - **Grade 5:** costs, coins, dollars and cents, costs together, change, money left after buying, how many one can buy, unit prices, the clock, hours between, days and months apart, durations, parts of an hour, mixed time units, today from its neighbours, dozens and pairs, half and double, ages, amounts left, years and birthdays. - **Grade 6:** each, sharing, full groups and what is left over, remainders, multiples and factors, what fits in, units, metric units and mixed units, units back, scaling amounts, two-step problems, the missing number, sequences, digit sums, counting words. - **Grade 7:** fractions and comparing them, percent, discounts, percent increase, area and perimeter, the perimeter of a triangle, roman numerals, rounding, squares and cubes, square roots. - **Grade 8:** averages, median, mode, range, speed and distance, travel time, unknowns, functions, definitions. - **Grade 9:** capitals and materials, titles and languages, kind words, what kinds do, kinds with a quality, inherited kinds, superlative kinds, where countries are, what animals eat. - **Grade 10:** directions, positions, paths, the far end, kinship, grandparents. - **Grade 11:** deduction, induction, motives, choices, which is not, what is absent, yes or no after a place, many questions on one statement, a colour at the end of a question, plurals, numbers in words, chains of one relation, claims. - **Grade 12:** scenes of two to five statements with many questions each, from several wordings, both directions, yes and no, and things the scene does not name. - **University:** chains walked several steps, kinds three deep, counts summed, split or scaled, relations asked backwards, what follows from a rule, and arithmetic that needs a calculator. ### 🔁 Procedure 1. `dam word teach` is the teacher. It is deterministic: for every word of every line it writes the moves that shape the tree the line expects and answer its questions, each move run on the same world the network runs on. A line the teacher does not reach is never taught. It reaches every learned line and, as a control, every held-out line. It writes the stack and the step taken, at every step, as rows, and a second copy of each row with the names the lessons state blanked, so a name never seen reads as they do. 2. `dam word train` trains a network from the rows of the learned lines: 230,141 rows, item width 16, 512 hidden units, AdaGrad with a learning rate of 0.05, softmax cross-entropy over the step classes and over the words the pointer may take. Three networks were trained, from seeds 1, 2 and 3. Each run stopped after 300 epochs with no fewer rows taken wrongly, at between 355 and 404 epochs, with 10 of the 230,141 rows not chosen as taught in each. The rows are not committed; `dam word teach` makes them again. ### 🖥️ Compute Each network trains in minutes on one consumer graphics card. The place and the power drawn were not recorded, so the card gives no `co2_eq_emissions`. ## 📁 Files | File | Holds | |---|---| | `config.json` | The step limit, the network's shape, its one voter and its step classes, and the build commit | | `model.safetensors` | The eight tensors of the network, listed below | | `state.bin` | The permanent state every chat starts from: the tree the seeds make | | `LICENSE`, `NOTICE.md` | The licence and what it covers | The tensors of `model.safetensors`, `N` being 0, the one voter: | Tensor | Type | Shape | |---|---|---| | `network.N.items` | `U64` | 4,235 | | `network.N.item_table` | `F32` | 4,235 by 16 | | `network.N.slot_weights` | `F32` | 200 by 512 by 16 | | `network.N.fill_weights` | `F32` | 200 by 512 | | `network.N.hidden_bias` | `F32` | 512 | | `network.N.output_weights` | `F32` | 104 by 512 | | `network.N.output_bias` | `F32` | 104 | | `network.N.point_weights` | `F32` | 512 by 16 | No file contains code. A tensor runtime cannot run DAM1; it is read by the dam-core crate. ## 🛠️ Use The crates are not on crates.io. Take them from the source repository. The repository must be public, or you must be signed in with `hf auth login`, for the download to work. From the command line, in a checkout of the source repository: ```sh cd huggingface && cargo build --release target/release/dam1 pull --repo DatamineNetwork/DAM1 target/release/dam1 talk --repo DatamineNetwork/DAM1 "tom has a red car." "what color is tom's car?" ``` Each text after `talk` is one turn of the same conversation. `--revision` picks a branch, tag or commit; `--model DIR` reads a folder already on disk. Each reply is printed as JSON: `output` is what the model said, `steps` is every step the networks chose at every word, `told` is what the turn wrote to the tree, and `ended` says whether every word continued within the step limit. From Rust: ```toml [dependencies] dam1 = { git = "https://github.com/Datamine-Crypto/DAM1" } dam1-hub = { git = "https://github.com/Datamine-Crypto/DAM1" } dam-page = { git = "https://github.com/Datamine-Crypto/DAM1" } ``` ```rust fn main() -> Result<(), String> { let folder = dam1_hub::hub::pulled("DatamineNetwork/DAM1", "main")?; let model = dam1::model::loaded(&folder)?; dam_page::load(&model.network.weights, &model.network.classes)?; dam_page::state(&model.state)?; dam_page::read("tom has a red car.", model.reading.steps)?; println!("{}", dam_page::read("what color is tom's car?", model.reading.steps)?); Ok(()) } ``` `dam_page` holds one conversation. `forget` takes it back to the seeds' state; `context` and `restore` save and load it. ## 📊 Evaluation The lessons are the training data. Each file mixes learned lines with lines held out of training. Measured with `dam1 check` on these files, run from `model/`: ```sh dam1 check --model ../huggingface/model --network data/network/release.bin ``` The check compares every tensor byte for byte with the network the files were exported from, and the state with the seeds told again. It then reads every line with the networks alone, no teacher and no search, from the state every seed makes. A line is right when every word of every input continued within the step limit and the tree holds the expected shape or the output says the expected answer. | Lessons | Learned lines | Held-out lines | |---|---:|---:| | Basics | 446 of 446 (100.0%) | 142 of 142 (100.0%) | | Grade 1 | 73 of 73 (100.0%) | 24 of 24 (100.0%) | | Grade 2 | 688 of 688 (100.0%) | 241 of 242 (99.6%) | | Grade 3 | 248 of 248 (100.0%) | 96 of 97 (99.0%) | | Grade 4 | 273 of 273 (100.0%) | 91 of 91 (100.0%) | | Grade 5 | 175 of 175 (100.0%) | 72 of 72 (100.0%) | | Grade 6 | 158 of 158 (100.0%) | 58 of 58 (100.0%) | | Grade 7 | 85 of 85 (100.0%) | 35 of 35 (100.0%) | | Grade 8 | 79 of 79 (100.0%) | 33 of 33 (100.0%) | | Grade 9 | 150 of 150 (100.0%) | 65 of 66 (98.5%) | | Grade 10 | 26 of 26 (100.0%) | 9 of 9 (100.0%) | | Grade 11 | 84 of 84 (100.0%) | 23 of 23 (100.0%) | | Grade 12 | 39 of 39 (100.0%) | 11 of 11 (100.0%) | | University | 47 of 47 (100.0%) | 13 of 13 (100.0%) | | World and debug cases | 36 of 36 (100.0%) | 32 of 32 (100.0%) | | **All** | **2607 of 2607 (100.0%)** | **945 of 948 (99.7%)** | It reads every learned line of the curriculum. The three held-out lines it misses are a statement of what we like, a question of whether one letter follows another read backward through the alphabet, and the last day of the week asked with no week named. The held-out lines use the same sentence shapes and many of the same words as the learned lines. They measure new words and numbers in taught shapes. They are not an independent benchmark. No result is given in the Hub's evaluation format, because the lessons are not a Hub benchmark dataset. ## ⚠️ Limitations and risks - English only, and only the sentence shapes its lessons taught. A shape it was not taught often reads wrong. - It knows what it is told and what the seeds state, nothing more. It has no general world knowledge. - A wrong reply looks the same as a right one. Check what it says. - It accepts what it is told as true and says it back. It has no filter for false, harmful or offensive statements. - The seeds are the project's own sentences and reflect what the project wrote. - The stack holds 200 events and one sentence, so a very long sentence loses its first words. A word that does not continue within 50 steps ends the turn as not ended. ## 📖 Citation ```bibtex @software{dam1_2026, author = {{Datamine Network Inc.}}, title = {DAM1: an LLM that reads one word at a time into a tree, with networks over its stack}, year = {2026}, url = {https://github.com/Datamine-Crypto/DAM1}, note = {Model files built at the commit the config records} } ``` There is no paper. ## ✉️ Contact Open a discussion in the Community tab of this repository, or an issue in the source repository. ## ⚖️ Licence Copyright 2026 Datamine Network Inc. The code, the lessons, the seeds and these weights are released under the GNU Affero General Public License, version 3 or later. If you run a modified version for users over a network, you must offer them its source. The names DAM1 and Datamine Network are not licensed for use by modified versions. See `LICENSE` and `NOTICE.md`.