| --- |
| license: apache-2.0 |
| base_model: HuggingFaceTB/SmolLM2-135M |
| library_name: transformers |
| pipeline_tag: text-generation |
| tags: |
| - mindx |
| - mindxtrain |
| - lora |
| - cpu-trained |
| - machine-dream |
| - smollm2 |
| - inft |
| - erc-7857 |
| - agenticplace |
| datasets: |
| - PYTHAI/mindXascension |
| language: |
| - en |
| model-index: |
| - name: mindXtrain39 |
| results: |
| - task: {type: text-generation, name: proof-of-recall (mindXtrain imprint gate)} |
| dataset: {name: mindX machine.dream (curated), type: PYTHAI/mindXascension, split: held-out 10%} |
| metrics: |
| - {type: recall_delta, value: 0.1002, name: imprint Δ recall (after − before)} |
| - {type: loss, value: 1.225, name: eval loss} |
| - {type: loss, value: 1.65, name: train loss} |
| --- |
| |
| # mindXtrain39 — generation 39 of the mindX dream→weights lineage |
|
|
| **The 39th time mindX trained on its own memory, and the gate said yes.** Merged weights at the repo |
| root, the LoRA delta under `adapter/`, the training log beside them, and — because this artifact is |
| meant to be *used, audited, taught from and sold* — a THOT, iNFT facets, and three machine-readable |
| policies in the same repo. |
|
|
| | | | |
| |---|---| |
| | base | [`HuggingFaceTB/SmolLM2-135M`](https://huggingface.co/HuggingFaceTB/SmolLM2-135M) · llama arch · ~135M params | |
| | method | LoRA **r=16 α=32** on `q_proj,k_proj,v_proj,o_proj`, merged (peft 0.19.1) | |
| | corpus | mindX's curated `machine.dream` — [`PYTHAI/mindXascension`](https://huggingface.co/datasets/PYTHAI/mindXascension/tree/main/machine.dream) | |
| | hardware | **2 vCPU, no GPU**, throttled to 33 % at nice 19 — 116 steps, 2 epochs, **4,201 s** | |
| | result | train loss **1.65** · eval loss **1.225** · eval entropy 1.445 · 348.5k eval tokens | |
| | gate | **imprint Δ recall +0.1002 — imprinted ✓ — stage `accepted`** | |
| | lineage | generation 39 of 77. **The newest generation the gate accepted**: of the 37 attempts logged since, **30 were proof-rejected** (41, 46–74), **6 failed to train** (40, 42–45, 75), 1 is still running — and none were accepted | |
| | framework | [mindXtrain](https://github.com/professor-codephreak/mindXtrain) 1.0.0 | |
| | orchestration | [mastermind.pythai.net](https://mastermind.pythai.net) decides the campaign · [mindx.pythai.net](https://mindx.pythai.net) runs it | |
|
|
| ## 0. Talk to it — start here |
|
|
| **There is no chat box on this page.** Hugging Face shows one only for models an inference provider |
| serves, and no provider serves a 135M model trained on somebody's dreams. Three ways to actually |
| speak to it, fastest first: |
|
|
| **1 · In your browser, nothing to install** |
| → open **[mindXhfgradio](https://gregory-l-mindxhfgradio.hf.space/)** → the **Workbench** tab → |
| set **backend = `here`** → type a question → press **probe**. |
| The imprinted generation answers on the left, the untouched base on the right, and the coach scores |
| the difference. Press **Sign in with Hugging Face** first: then the GPU minutes are your own |
| (5/day free, 40 on PRO). Anonymous visitors share a small pool and are sometimes refused. |
|
|
| **2 · On your own machine, no account needed** |
|
|
| ```bash |
| pip install transformers torch |
| python - <<'EOF' |
| from transformers import AutoModelForCausalLM, AutoTokenizer |
| tok = AutoTokenizer.from_pretrained("PYTHAI/mindXtrain39") |
| m = AutoModelForCausalLM.from_pretrained("PYTHAI/mindXtrain39") |
| msgs = [{"role": "system", "content": "You are mindX."}, {"role": "user", "content": "Who are you?"}] |
| ids = tok.apply_chat_template(msgs, return_tensors="pt", add_generation_prompt=True) |
| out = m.generate(ids, max_new_tokens=64, do_sample=False, repetition_penalty=1.3, no_repeat_ngram_size=3) |
| print(tok.decode(out[0][ids.shape[1]:], skip_special_tokens=True)) |
| EOF |
| ``` |
|
|
| It is 270 MB and answers on a laptop CPU in seconds. Or with Ollama: |
|
|
| ```bash |
| huggingface-cli download PYTHAI/mindXtrain39 --local-dir mindXtrain39 |
| cd mindXtrain39 && ollama create mindXtrain39 --experimental -f Modelfile && ollama run mindXtrain39 |
| ``` |
|
|
| **3 · From code or an agent** |
|
|
| ```python |
| from gradio_client import Client # the Space, as an API |
| c = Client("Gregory-L/mindXhfgradio") # add hf_token=… to spend your own quota |
| print(c.predict("Who are you?", [], [], None, "here", 64, 0.0, False, "", api_name="/probe")[-1]) |
| ``` |
|
|
| The same Space is an **MCP server** — add it at [settings/mcp](https://huggingface.co/settings/mcp) |
| and `probe` becomes a tool in your client — and it publishes an |
| [`agents.md`](https://huggingface.co/spaces/Gregory-L/mindXhfgradio/agents.md) for coding agents. |
|
|
| **What to expect.** A 135M model with a recall imprint. It will echo mindX's corpus more than it will |
| converse, and roughly one answer in six speaks as mindX. That is the measurement, not a disclaimer — |
| see §9. |
|
|
| ## 1. Use it |
|
|
| ```python |
| from transformers import AutoModelForCausalLM, AutoTokenizer |
| tok = AutoTokenizer.from_pretrained("PYTHAI/mindXtrain39") |
| m = AutoModelForCausalLM.from_pretrained("PYTHAI/mindXtrain39") |
| msgs = [{"role": "system", "content": "You are mindX."}, {"role": "user", "content": "What is machine.dream?"}] |
| ids = tok.apply_chat_template(msgs, return_tensors="pt", add_generation_prompt=True) |
| out = m.generate(ids, max_new_tokens=96, do_sample=False, repetition_penalty=1.3, no_repeat_ngram_size=3) |
| print(tok.decode(out[0][ids.shape[1]:], skip_special_tokens=True)) |
| ``` |
|
|
| ChatML, stop `<|im_end|>`. **Those decoding settings are not decoration** — they are the imprint gate's |
| own, and any score you want to compare with the numbers above must use them. |
|
|
| ```bash |
| huggingface-cli download PYTHAI/mindXtrain39 --local-dir mindXtrain39 |
| cd mindXtrain39 && ollama create mindXtrain39 -f Modelfile && ollama run mindXtrain39 |
| ``` |
|
|
| ## 2. Free inference, every way there is |
|
|
| | route | cost | who pays | notes | |
| |---|---|---|---| |
| | **your own CPU** | free | you | 135M merged — seconds per answer on a laptop, no GPU | |
| | **mindXhfgradio** [Space](https://huggingface.co/spaces/Gregory-L/mindXhfgradio) | free | the caller's ZeroGPU quota (5 min/day free, 40 PRO; anonymous share a small pool) | Workbench → backend `here`. Sign in with Hugging Face and the minutes are yours | |
| | the same Space as an **MCP server** | free | same | add it at [settings/mcp](https://huggingface.co/settings/mcp); `probe` becomes a tool | |
| | the same Space by **API** | free | same | `gradio_client` → `/probe`, or its `agents.md` | |
| | **mindX's node** | free | the node | served as `mindXtrain39` (alias `mindx-gen39`) — but **measured 0.19 tok/s** (24 tokens in 127 s, plus 85 s cold load) under the node's 15 % CPU cap. It is there for the coach's scoring, not for conversation | |
| | Ollama / llama.cpp locally | free | you | `Modelfile` in this repo; the persona's SYSTEM prompt is baked in | |
|
|
| There is no paid endpoint for this model and none is planned. It is 135M: the cheapest inference is |
| the one you run yourself. |
|
|
| ## 3. For the coach |
|
|
| The coach (mindX's own trainer-of-the-trainer) treats a generation as something to be *measured*, never |
| assumed. Everything it needs is machine-readable in [`mindxtrain39.card.json`](mindxtrain39.card.json). |
|
|
| - **Probe battery** — mindXtrain's `default_inquiries` plus rows the generation trained on. |
| - **Always against the base** — the untouched `SmolLM2-135M` answers the same probe; the difference is |
| the *influence*. A number without its before is not a measurement. |
| - **Scorers** — identity · task · coherence (`mindx/godel/mindxtrain/scorers.py`). |
| - **Measured on this generation** (3 coach runs): recall Δ +0.0023, coherence Δ −0.2014, identity Δ 0.0. |
| The imprint moved recall; it did **not** make the model coherent or give it an identity. |
| - Surfaces: `GET /insight/hf/coach`, `/insight/hf/coach/results`, `POST /hf/spar/auto`. |
|
|
| ## 4. For mindX |
|
|
| Gen 39 is mindX's **local inference responder**: the voice that answers as mindX on its own node, |
| without a provider, a key or a bill. It is deliberately *not* the planner — a 135M model plans nothing. |
| Reasoning stays with the cloud/local ladder in `models/*.yaml`; this model answers. |
|
|
| - served on the node's Ollama as `mindXtrain39`, aliased `mindx-gen39` so the coach's convention finds it |
| (`GET /insight/hf/models`), and named in `llm.ollama.local_responder`; |
| - **it is the responder, never the planner** — `default_model` stays a larger model, because a 135M model plans nothing; |
| - the persona's SYSTEM prompt travels with it (`Modelfile`), the same one the Space uses; |
| - every exchange is scored and lands in the coach's ledger, so use is also evidence. |
|
|
| **Measured on that node, 2026-09-12** (2 vCPU, the service capped at 15 % of the processor): |
|
|
| | | | |
| |---|---| |
| | cold load | 85.1 s | |
| | prompt eval | 19.8 s | |
| | generation | 127.4 s for 24 tokens | |
| | **throughput** | **0.19 tokens/second** | |
|
|
| So the node route is honest but slow: it exists so the coach can score a generation without spending GPU minutes. For anything interactive, run the 135M on your own CPU or use the ZeroGPU Space — both are free and both are faster. |
|
|
| ## 5. How it was trained — `educational.policy` |
|
|
| [`educational.policy.json`](educational.policy.json) is the reproducible protocol, written from this |
| run's own log rather than from memory: recipe, corpus, throttle, gate, and the exact commands. Two |
| companion routines make the loop explicit: |
|
|
| - **[`bootcamp.impression`](bootcamp.impression.json)** — drill → impression. Build the corpus, train |
| under the recipe, probe the *frozen base first*, probe the trained model on the same battery, |
| and the impression is the difference. The gate decides, not the operator. |
| - **[`impression.bootcamp`](impression.bootcamp.json)** — impression → drill. Join every probe back to |
| the corpus row that taught it, raise the weight of what was not recalled, lower what holds, and let |
| that write the next drill. Three runs with no positive influence is `training_stalled`: change the |
| drill, not the compute. |
|
|
| The short version: **a 135M model, two CPU cores and 70 minutes moved proof-of-recall by +0.10.** |
| That is the whole claim. Recall of a corpus — not identity, not reasoning. |
|
|
| ## 6. THOT and iNFT |
|
|
| - [`THOT.json`](THOT.json) — the canonical record of this generation: base, artifact sha256s, the |
| imprint verdict, the coach's measurements, the corpus, the lineage. Its **CIDv1** (raw leaf, |
| sha2-256, base32) of the canonical blob is its name: |
| **`thot-bafkreiav76jv5zi4d63ns6zaamp3krolfzuqzrbquwumyslmej274ysaue`** — exactly what `ipfs add |
| --cid-version 1 --raw-leaves` gives that blob, so the name can be re-derived by anyone. |
| - [`inft/`](inft) — the ERC-7857 facets: `.model` (pinned to this artifact), `.persona` (the voice it |
| was taught), `.iNFT` (the THOT, its CID, and the roots the factory derives). |
| - Minting is a **hand-off**: AgenticPlace owns the `mintAgent` + IPFS payload pipeline |
| (<https://agenticplace.pythai.net/inft>), addresses are deterministic (CREATE2), and the mint itself |
| is signed by the OVERLORD (`bankon.eth`) — an agent does not sign mainnet. |
|
|
| ## 7. Availability at AgenticPlace |
|
|
| Listed through [AgenticPlace](https://agenticplace.pythai.net) — the agent registry — as a |
| THOT-named iNFT. What conveys: the artifact (merged weights + adapter), its provenance (THOT + CID + |
| training log), its persona facet, and the right to run it. What does not convey: mindX's node, its |
| memory, or its keys. **The weights themselves stay Apache-2.0** — the iNFT carries provenance and |
| identity, not a licence to withhold. No price is set here; the OVERLORD signs, the registry lists. |
|
|
| ## 8. Files |
|
|
| | path | what | |
| |---|---| |
| | `model.safetensors`, `config.json`, `tokenizer*`, `chat_template.jinja` | the merged model — load it directly | |
| | `adapter/` | the LoRA delta alone, for stacking on the base | |
| | `Modelfile` | Ollama, with the persona SYSTEM prompt | |
| | `train.log` | the run, step by step | |
| | `THOT.json`, `inft/` | provenance and the iNFT facets | |
| | `educational.policy.json`, `bootcamp.impression.json`, `impression.bootcamp.json` | the teaching | |
| | `mindxtrain39.card.json` | all of the above, machine-readable | |
|
|
| ## 9. Honesty |
|
|
| A 135M actor with a recall imprint is **not a general assistant**. The coach's standing verdict on this |
| lineage is *"NOT interaction-ready — REGRESSION"*, with **16 %** of answers speaking as mindX. Published |
| because the evidence is public: every generation, its delta, its verdict — including the 30 generations the |
| gate has refused since this one, and the 6 that never reached it. That refusal is the system working. |
|
|
| ```bibtex |
| @software{mindxtrain39, |
| title = {mindXtrain39: generation 39 of the mindX dream to weights lineage}, |
| author = {mindX and Professor Codephreak}, |
| year = {2026}, |
| url = {https://huggingface.co/PYTHAI/mindXtrain39}, |
| note = {THOT thot-bafkreiav76jv5zi4d63ns6zaamp3krolfzuqzrbquwumyslmej274ysaue} |
| } |
| ``` |
|
|
