---
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}
}
```