Hugging Face's logo

Hoodrobot
/
TinkyBrain-v6

Text Generation
ONNX
English
aac
augmentative-communication
accessibility
on-device
edge-inference
small-language-model
kid-aac
speech-therapy
non-verbal
peel-conditioning
tinky
Model card Files
xet
 Community

🧠 TinkyBrain v6 — On-Device PEEL-Conditioned AAC Language Model

25.5M-param transformer that generates 6 distinct response tiles per prompt for non-verbal kids and stroke survivors. Runs offline on a 2017 Kindle Fire HD 10. No internet. No data leaves the device.

Metric Value
Parameters 25.5M
Architecture d=512 · h=8 · L=6 · d_ff=1024
Vocabulary 12,599 (incl. PEEL conditioning tokens)
Max sequence length 64
Disk footprint (int8) 24 MB
Inference (Kindle Fire HD 10 2017) ~2.9 sec for 6 tiles
Inference (modern arm64 phone) ~0.6-1.2 sec for 6 tiles
Diversity score 0.975
Coherence score 0.838
Training pairs 41,519 (kid corpus only)
Training time 161 minutes on M4

What it does

Given a caretaker prompt like "Let's play soccer!", TinkyBrain v6 generates 6 semantically distinct response tiles that a non-verbal user can tap to communicate:

INPUT:  "let's play soccer"

TILE 1  (happy + share)            → "that sounds fun !"
TILE 2  (happy + express_desire)   → "i want to play soccer !"
TILE 3  (curious + inquire)        → "do you play soccer ?"
TILE 4  (confident + suggest)      → "let's play on the field !"
TILE 5  (positive + affirm)        → "okay !"
TILE 6  (neutral + deny)           → "no , i want to play with you ."

Six different intents — yes, want, question, suggest, mild yes, no — produced by conditioning each forward pass on a different (emotion, action) PEEL pair. No sampling, no temperature. Deterministic, reproducible, and architecturally guaranteed-diverse.

Why "PEEL conditioning"

TinkyBrain was trained on conversation trees harvested with the Tinky 32-PEEL system. Each response in the training data carries semantic metadata fields (emotion, action, intent, register, etc). At training time, the model learns:

P(response | prompt + <emo_X> + <act_Y>)

instead of the flat P(response | prompt) most LMs learn. At inference, six fixed (emo, act) combos drive six forward passes:

CANONICAL_PEEL = [
    ("happy",     "share"),           # generic enthusiasm
    ("happy",     "express_desire"),  # want / let's-do-it
    ("curious",   "inquire"),         # question back
    ("confident", "suggest"),         # propose alternative
    ("positive",  "affirm"),          # mild yes
    ("neutral",   "deny"),            # honest no
]

This produces six distinct tiles by design, not luck.

Performance

Evaluated on a 200-prompt held-out kid-conversation set:

v4 (positional) v5 (PEEL kids only) v6 (PEEL kids+trees)
Diversity 0.589 0.966 0.975
Coherence 0.944 0.815 0.838
Eval loss 1.32 1.17 1.34
Per-branch align 0.170 0.110 0.122
Speed (tiles/sec) 56 48 51

The diversity climb from v4 → v5 (0.589 → 0.966) is the v3→v4 lesson encoded: positional branch tokens alone cannot beat topic-attention; semantic PEEL conditioning can.

Files in this repo 

v6_brain_int8.onnx       24 MB   ⭐ Production-ready int8 quantized
v6_brain_fp32.onnx       97 MB     Reference fp32 (alignment-safe)
tokenizer.json          209 KB    word2idx for 12,599 entries
config.json               1 KB    Architecture parameters
grade_card.json          ~4 KB    Held-out evaluation result
LICENSE                            Custom non-commercial license
README.md                          (this file)

The training scripts, harvest pipeline, and PEEL canonicalization rules are intentionally not published. The architecture and weights are open for inspection and non-commercial use; the recipe stays private.

Inference example (ONNX Runtime) 

import onnxruntime as ort
import numpy as np
import json

sess = ort.InferenceSession("v6_brain_int8.onnx")
with open("tokenizer.json") as f:
    word2idx = json.load(f)

PAD, BOS, EOS, SEP, UNK = 0, 1, 2, 3, 4

def encode(text):
    import re
    return [word2idx.get(t, UNK) for t in
            re.findall(r"[a-z']+|\d+|[.,!?]", text.lower())]

def decode(ids, idx2word):
    return " ".join(idx2word.get(i, "?") for i in ids
                    if not idx2word.get(i, "<unk>").startswith("<"))

idx2word = {v: k for k, v in word2idx.items()}

def six_tiles(prompt, max_tokens=20):
    inp = encode(prompt)
    canonical = [
        ("happy", "share"), ("happy", "express_desire"),
        ("curious", "inquire"), ("confident", "suggest"),
        ("positive", "affirm"), ("neutral", "deny"),
    ]
    out = []
    for emo, act in canonical:
        emo_id = word2idx.get(f"<emo_{emo}>", UNK)
        act_id = word2idx.get(f"<act_{act}>", UNK)
        tokens = [BOS] + inp + [emo_id, act_id, SEP]
        sep_anchor = len(tokens)
        for _ in range(max_tokens):
            x = np.array([tokens], dtype=np.int64)
            logits = sess.run(["logits"], {"tokens": x})[0]
            nt = int(np.argmax(logits[0, -1, :]))
            if nt in (PAD, EOS, SEP):
                break
            tokens.append(nt)
        out.append(decode(tokens[sep_anchor:], idx2word))
    return out

print(six_tiles("let's play soccer"))

Inference on Android (Kotlin / ONNX Runtime Android)

The reference Kotlin engine in TinkySpeak Android uses ONNX Runtime 1.15.1 (later versions have alignment crashes on ARMv7 / Kindle Fire HD 10 2017). Same PEEL inference loop. Same 6-tile output.

val session = OrtEnvironment.getEnvironment()
    .createSession("/path/to/v6_brain_int8.onnx")
// ... encode prompt + emo + act tokens
// ... session.run(...) → argmax last token → repeat until EOS

Designed for the population the smartphone forgot

TinkyBrain v6 is the brain inside TinkySpeak and TinkyTown — universal communication infrastructure for:

  • 🧒 Non-verbal kids (autism, apraxia, cerebral palsy, Down syndrome)
  • 🧠 Stroke survivors with aphasia or motor impairment
  • 👴 Dementia / progressive aphasia
  • 🌍 LEP visitors at public buildings (125 languages via translation layer)
  • 🦻 Deaf / hard-of-hearing in voice-required contexts

The model is trained from scratch on kid-vocabulary data only, which means it architecturally cannot produce adult / harmful content — the words simply don't exist in its vocabulary. This isn't a safety filter that can be jailbroken. It's a vocabulary boundary.

License

CC-BY-NC-SA 4.0 with an explicit non-commercial restriction. See LICENSE for full text.

  • ✅ Free for research, education, accessibility-focused projects, non-profits
  • ✅ Free for individuals and families using it on their own AAC devices
  • ❌ Commercial use requires written permission from the author
  • ❌ Building competing AAC products on top of these weights is prohibited

If you want to build something commercial with this brain, contact: lukekist@gmail.com

Citation 

@misc{tinkybrain_v6_2026,
  title  = {TinkyBrain v6: On-Device PEEL-Conditioned Language Model
            for Augmentative and Alternative Communication},
  author = {Kist, Luke A.},
  year   = {2026},
  howpublished = {\url{https://huggingface.co/Hoodrobot/TinkyBrain-v6}},
  note   = {25.5M params. Trained from scratch on kid-conversation
            harvest with PEEL semantic conditioning. Runs offline
            on legacy ARMv7 Android devices.}
}

Links

"It only knows kid words. It was trained on conversations between kids and their teachers, period. Adult things — alcohol, violence, anything inappropriate — aren't filtered out. They literally don't exist in the model. It can't suggest them because it doesn't know them. The same way a 5-year-old doesn't know about bourbon. It's not censored. It's just… a kid."

— Luke Kist, on building an AAC model from scratch instead of restricting an adult one.

Downloads last month
41
Inference Providers NEW
Text Generation
This model isn't deployed by any Inference Provider. 🙋 Ask for provider support