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
1
Inference Providers NEW
Text Generation
This model isn't deployed by any Inference Provider. 🙋 Ask for provider support