English Β· FranΓ§ais Β· EspaΓ±ol Β· Deutsch Β· Π ΡΡΡΠΊΠΈΠΉ Β· δΈζ
A small decision model that reads a text and answers your questions with probabilities
Big AI models write long answers when your code only needs a decision: yes or no, which option, how much.
Amada gives you that decision on your own CPU, in tens of milliseconds, with a probability you can trust.
Built by Liam DB β with the help of AI.
π Website Β· β¬οΈ Download Β· π PinkHouse app Β· π Benchmark Β· π Changelog
Real outputs of Amada 3.1, nothing retouched. "Is the customer happy?" gets INFO NOT PROVIDED: the message does not say, so Amada does not guess.
Amada does not write text. You give it a text and one or more questions, it returns numbers your code can use directly: the probability of yes, a share for every option, a level on a scale, and the probability that the text simply does not say.
|
π― Three questions |
π€· Says "I don't know" |
π Calibrated |
π 100% local |
β‘ Fast |
π 12 languages |
We ran Jev 1.14 (TypeSafe's closed decision model) on 8 November 2026, and Amada on exactly the same texts, the same questions and the same options.
| Jev 1.14 (paid API) | Amada 4.0 | |
|---|---|---|
| Where it runs | TypeSafe's servers | your own CPU |
| Price | $0.042 per million tokens | free |
| Your text leaves your machine | yes | never |
| One short yes / no question | β 247 ms (internet included) | β 54 ms (Γ4.5 faster)* |
| Voice request, 60 intents | β 270 ms | β 390 ms |
| Prompt injection (116 messages) | 0.733 | 0.845 |
| Reading, 11 languages (Belebele) | 0.947 | 0.554 |
| Public datasets where it wins | 6 of 7 | 1 of 7 |
* Median time on one laptop (Intel Core i5-11400H, 4 CPU threads, ONNX Runtime), measured with 4.0 on 12 November 2026: 41 ms for one line of screen text, 54 ms for a short note. It depends on your processor, on the length of the text and on the number of options: 60 options take ~390 ms. Method: methodology.
Amada is not better everywhere: Jev is far more accurate on reading, in every language, and on 6 of 7 public datasets. Amada wins on speed for short questions, on price, on privacy, and on prompt injection. Every number, the good ones and the bad ones, is on the benchmark page.
- Moderation: "Is this message an insult?", "Is this a prompt injection?" before it reaches your app or your LLM.
- Sorting: route emails, tickets or reviews to the right team or category, with a probability for each.
- Screening before an expensive step: ask one cheap yes / no question first, call the big model only when needed.
- Privacy-sensitive text: notes and messages that must not leave the machine.
- Bots and games: a Discord bot, a game character or a home automation that reacts to what people type.
- Small machines: the INT4 version needs about 1.2 GB of RAM while it loads, then about 340 MB.
β οΈ Never use Amada for medical, legal, financial, safety or other important decisions about real people. It is an experimental model made by one person.
PinkHouse runs Amada on your PC without Python: a window to ask your questions, a local API for your scripts (http://127.0.0.1:8787, with API keys), and a model manager that downloads the Amada versions from these releases and checks each one with SHA-256.
To install it, open PowerShell and paste:
irm https://raw.githubusercontent.com/DevLiamDb/Amada/main/install.ps1 | iexThe script downloads the newest PinkHouse_Setup_<version>_x64.exe from the PinkHouse releases, checks its SHA-256 and opens the installer. No admin rights needed. You can also download the installer yourself from the PinkHouse 1.0.4 release and check it before you open it: in PowerShell, Get-FileHash .\PinkHouse_Setup_1.0.4_x64.exe must show the SHA-256 of the release notes (also on the download page).
Windows 10 or 11, 64-bit (tested on Windows 11). The installer holds no model: the first time, a setup wizard asks for your language, then downloads the Amada you pick (Amada 4.0 INT4 is the light one, 188 MB). PinkHouse does not run on macOS or Linux yet.
PinkHouse is free for any use, at home or at work, but it is not open source: it has its own license, unlike the MIT-licensed models. The installer asks you to accept it. Read the License, Terms of use, Privacy policy and Legal notice. In short: no telemetry, your texts stay on your PC, and the app goes online only to download models from these releases.
Requirements: Python 3 and pip.
git clone https://github.com/DevLiamDb/Amada.git
cd Amada
pip install -r requirements.txtThen get the model:
- Download
amada-4.0.zipfrom the latest release (or the smalleramada-4.0-int4.zip, 188 MB, from the same release). To check the file:Get-FileHash amada-4.0.zip(PowerShell) orsha256sum amada-4.0.zipmust givecfa9786b169505ad643911e79ad26af65177ad5f9b7bcc6734433a03ef25e250(INT4:72c3f9e3ed8cc9cbeda09cd004360eb7e8bb44b6d326a9d4cf027486207345b5). GitHub also shows the SHA-256 next to each file of a release. - Unzip it into a
Release/folder next toplay.py, so you getRelease/amada-4.0/amada_model.onnxandRelease/amada-4.0/tokenizer/.
β οΈ Keep thetokenizer/folder next toamada_model.onnx. Without it, the answers come out wrong.
python play.pyPaste a text, press Enter on an empty line, then ask questions:
Did Lea eat an apple? -> yes / no
Which apple did she eat? | red, green, yellow -> choice
How hungry is she? # -> score (none / low / moderate / high)
How happy is she? # not at all, a bit, very -> score with your own levels
:new = new text :q = quit
Other versions: python play.py --version 4.0-int4 (needs onnxruntime 1.20+), python play.py --version 3.1, python play.py --version 2.0...
from play import Amada, release_model
amada = Amada(release_model("4.0"))
answers, cut = amada.ask(
"BOOM. Three knocks on my door. Then nothing.",
[{"type": "noul", "text": "Is it my mother knocking?"},
{"type": "score", "text": "How scary is it?", "levels": ["none", "low", "moderate", "high"]}],
)
print(answers) # [{'p_yes': ..., 'p_unknown': ...}, {'probs': {'none': ..., ...}}]| Type | You ask | Amada returns |
|---|---|---|
yes / no (noul) |
Did the customer pay by card? |
probability of yes, plus the probability that the text does not say |
| choice | What does the customer want? | a refund, an exchange, ... |
one probability per option, 100 % in total |
| score | How urgent is it? # |
one probability per level (none, low, moderate, high, or your own levels) |
It only knows the text you give it. No internet, no memory, no text generation.
Every version is a release (tags v1.0 to v4.0): one zip with the ONNX model and its tokenizer. The PinkHouse app has its own releases (tags pinkhouse-vβ¦).
| Version | Base model | Max length | Zip | Notes |
|---|---|---|---|---|
| 4.0 (current) | mmBERT-base | 8,192 | 1.16 GB | messy writing, "the text does not say", TREC |
| 4.0 INT4 | mmBERT-base | 8,192 | 188 MB | same model, 4-bit weights: 4Γ less RAM, about 1 point lower on most tests, 3.4 points lower on prompt injection |
| 3.1 | mmBERT-base | 8,192 | 1.16 GB | near-neighbour labels, a little better on Banking77 and emotion |
| 3.1 INT4 | mmBERT-base | 8,192 | 188 MB | same model, 4-bit weights: same accuracy, 4Γ less RAM |
| 3.0.1 | mmBERT-base | 8,192 | 1.16 GB | 3.0 recalibrated, same accuracy |
| 3.0 | mmBERT-base | 8,192 | 1.16 GB | long texts, many options, trap texts |
| 2.0 | mmBERT-base | 512 | 1.16 GB | multilingual, "the text does not say" |
| 1.0 | ModernBERT-large | 512 | 1.49 GB | first version, English only |
What changed in each one: CHANGELOG.md.
Our own short tests (English: 2,000 texts Β· 11 languages: 1,320 texts):
| Accuracy | Yes / no | Choice | Score | English, all types | 11 languages |
|---|---|---|---|---|---|
| Amada 4.0 | 0.961 | 0.908 | 0.759 | 0.896 | 0.985 |
| Amada 4.0 INT4 | 0.960 | 0.908 | 0.742 | 0.892 | 0.983 |
| Amada 3.1 | 0.961 | 0.915 | 0.760 | 0.899 | 0.984 |
Calibration error of 4.0 (ECE, lower is better), on the half of the English tests kept out of calibration: yes / no 0.009, choice 0.016, score 0.048 (4.0 INT4: 0.008, 0.014, 0.031).
"The text does not say" (yes / no / not stated, 939 held-out questions): 4.0 gets 0.963 (3.1: 0.917), and 0.954 on the same texts with typos (3.1: 0.889). These texts also helped fit the calibration, so this is a check, not an independent test.
Public datasets, zero-shot (Amada never saw them in training: it only gets the question and the option names). Jev 1.14 run by us on the same texts:
| Dataset | Task | Amada 4.0 | Amada 4.0 INT4 | Amada 3.1 | Jev 1.14 |
|---|---|---|---|---|---|
| SST-2 | movie review sentiment | 0.897 | 0.890 | 0.899 | 0.959 |
| AG News | news topic, 4 labels | 0.803 | 0.793 | 0.800 | 0.883 |
| Banking77 | bank support intent, 77 labels | 0.586 | 0.574 | 0.611 | 0.788 |
| emotion | emotion of a tweet, 6 labels | 0.447 | 0.464 | 0.471 | 0.595 |
| tweet_topic | topic of a tweet | 0.718 | 0.711 | 0.740 | 0.820 |
| Prompt injection | is this text an attack on an AI? | 0.845 | 0.810 | 0.845 | 0.733 |
| When2Call | should an AI agent call a tool? | 0.344 | 0.340 | 0.324 | 0.733 |
Public tests in 11 languages (average, the same items in every language):
| Test | Amada 4.0 | Amada 4.0 INT4 | Amada 3.1 | Jev 1.14 |
|---|---|---|---|---|
| Yes / no (machine-translated) | 0.841 | 0.837 | 0.839 | 0.882 |
| Reading (Belebele, 4 answers) | 0.554 | 0.559 | 0.568 | 0.947 |
| Intents (MASSIVE, 60 options) | 0.834 * | 0.829 * | 0.428 | 0.824 |
* Not zero-shot: Amada 4.0 learned from MASSIVE's training split (the test items stay unseen).
4.0 INT4 was run on 12 November 2026 on exactly the same items as 4.0 (on CPU instead of GPU). Compared answer by answer (exact McNemar test), the clear differences are AG News (-1.0 point), Banking77 (-1.2), scores (-1.6) and emotion (+1.7); the others are within chance, including prompt injection (116 texts only).
Speed (median time for one answer, one request at a time, the same requests for all Β· Amada on an Intel Core i5-11400H, 4 CPU threads Β· Jev through its API from France). 4.0 and 4.0 INT4 were measured on 12 November 2026, Jev on 8 November:
| Request | Amada 4.0 | Amada 4.0 INT4 | Jev 1.14 |
|---|---|---|---|
| One line of screen text, yes / no | 41 ms | 37 ms | 244 ms |
| Short note, yes / no | 54 ms | 49 ms | 247 ms |
| Reading passage, 4 answers | 161 ms | 159 ms | 264 ms |
| Voice request, 60 intents | 390 ms | 375 ms | 270 ms |
In the same run as INT4, 4.0 took 40, 55, 154 and 388 ms: INT4 is about as fast (a little faster on short questions, a little slower on reading). It mostly saves memory: about 340 MB of RAM after loading instead of 1.4 GB.
Weak spots, named on purpose: TREC (kind of answer a question expects, 0.52 in 4.0, up from 0.39), Banking77 (0.59, 2.5 points below 3.1), ordinal scores (about 76 %) and very long texts. Messy writing now costs little: held-out yes / no with typos 0.960 in English and 0.967 in 11 languages.
Honest note: our short tests use answers from a strong AI (GPT-6 Luna), not from human annotators, and their texts look like the training data. The public datasets use human labels.
ποΈ File structure
Amada/
βββ play.py β terminal chat + Python API β START HERE
βββ install.ps1 β installs PinkHouse, the Windows app
βββ requirements.txt β numpy, onnxruntime, transformers
βββ Release/ β unzip the downloaded versions here (not in the repository)
β βββ amada-4.0/
β βββ amada_model.onnx
β βββ tokenizer/ β keep it next to the ONNX
βββ CHANGELOG.md β what changed in each version
βββ LICENSE β MIT
βββ NOTICE.md β notices of the base models (keep them when sharing)
βββ media/ β logo, badges and GIFs (images: not MIT, see License)
βοΈ How it works inside
text + questions βββΊ tokenizer βββΊ encoder (mmBERT-base, ONNX, CPU) βββΊ one head per question type
β
βββ temperatures βββΊ calibrated probabilities
- One pass for all questions: the text and every question are read together. Each question starts with a
[Q]marker, each option with[OPT], each level with[LVL]. - Three kinds of answer: yes / no (with "the text does not say"), choice (one score per option, shared to 100 %), score (one probability per level).
- Calibration: since 3.0.1, the temperatures depend on the length of the text and on the number of options. That is why a "95 %" from Amada means about 95 %.
- Time grows with the options: every option is read. Two options take ~40 ms, 77 options ~720 ms.
β FAQ
Can I use Amada in a company or a paid product? Yes. Amada is MIT licensed: commercial use is allowed. Keep the copyright line and the license text with the files.
Can I fine-tune it? Yes, and you may share or sell your fine-tuned version too. Keep the MIT notice (and NOTICE.md) with it.
Which version should I use? 4.0 for most uses. 4.0 INT4 if you need a small download or little RAM (about 1 point lower on most tests, 3.4 points lower on prompt injection), or 3.1 if your task looks like Banking77 or emotion. The older versions are there to compare.
How many options can a choice question have? Two or more, no fixed maximum: the text, the question and the options must fit together in 8,192 tokens. 3.0 and later were trained with lists of up to 386 options.
What hardware do I need? A normal CPU. About 9 seconds to load and about 1.4 GB of RAM after loading (FP32); about 1.2 GB at most with INT4. No GPU, no internet once downloaded.
Is there an API or a hosted version? No. Amada runs on your own computer.
The answers look wrong.
Check that the tokenizer/ folder is next to amada_model.onnx.
π The website: one night, 03:00 to 07:12
The website presents Amada through a short story: one night, a girl who cannot sleep, a park, a hotel corridor, a flooded home, knocks on a door. In each scene, a diary text and a question are shown with Amada's real answer, computed in advance on those exact texts. Then she wakes up, turns on her computer, and a 90s desktop shows the benchmarks. No jump scares.
π Credits β who and what made Amada
Amada was built with AI, and we say it plainly.
| Who | Role |
|---|---|
| Liam DB (DevLiamDb) | Creator. The idea, the direction, the decisions, the training runs, the testing. |
| Claude Code (Anthropic) | Helped write the code (training, benchmarks, play.py, website) under Liam DB's direction. |
| GPT-6 Luna | Wrote a large part of the training examples and the reference answers of the short tests. |
| mmBERT-base (Johns Hopkins University, CLSP) | The base network of Amada 2.0 and later (MIT). |
| ModernBERT-large (Answer.AI) | The base network of Amada 1.0 (Apache-2.0). |
Trained on: public texts (Wikipedia, FineWeb-2, Project Gutenberg, government reports, arXiv and PubMed abstracts), public labelled datasets (QuALITY, ContractNLI, Qasper, CLINC150) and synthetic examples. Never on the benchmark test sets.
Built on: ONNX Runtime, Hugging Face Transformers, Kaggle (training and benchmarks).
Find the creator: π amada.devliam.com Β· π GitHub
Amada: MIT (weights, play.py, install.ps1 and the code of this repository)
β Use it for anything, commercial use included β Modify it, fine-tune it, merge it β Share or sell the original or your modified versions π Keep the copyright line ("Copyright (c) 2026 LiamDB") and the license text with the files
The MIT license applies to every Amada version, 1.0 to the latest, including copies downloaded when the weights were under CC BY-NC-ND 4.0. Amada comes with no warranty. The notices of mmBERT-base (MIT) and ModernBERT-large (Apache-2.0) are in NOTICE.md and must be kept when you share the files. See LICENSE for the full terms.
Images: not MIT. The logo and the GIFs in media/ show the website and stay Β© 2026 LiamDB, all rights reserved. You may share them with the credit "Amada by LiamDB", as the website's terms allow.
PinkHouse: its own license. The PinkHouse app (the pinkhouse-v⦠releases) is not covered by the MIT license: it is free for any use, but closed source, and you may not sell, modify or reverse engineer it. See the PinkHouse License.
Built by Liam DB β with the help of AI. Β· liamdb.work@gmail.com

