dk Dark Knight 2026-09-09 6 min read

Desert Ant Labs: I Tested the 2MB Tongue Model

Yesterday a European lab called Desert Ant Labs launched with 18 on-device models, and the flagship claim is absurd on its face: a 2MB model that names the language from three words, beating a 293MB detector. Small enough to be marketing fiction. So I pulled the weights off Hugging Face, reimplemented their inference pipeline from the algorithm docs, validated it against their shipped golden vectors, and ran my own 25-language benchmark. The number I got: 123/125, 98.4% on three-word inputs. The 2MB claim is literal — the int8 weights are exactly 2,104,940 bytes.

What Tongue actually is

There is no neural network in the way you're imagining. No transformer, no encoder, no tokenizer file. It's a character n-gram bag: FNV-1a-hash every character n-gram (orders 1–5, wrapped with ^/$ boundary markers), look each up in a 65,536×32 int8 embedding table, sum, apply a 59×32 linear head. That's the whole model. The hash table is the feature space, which is why size doesn't grow with language count and why there's no tokenizer to version-match.

On top sits a zero-parameter script router: Hangul → Korean, Greek → Greek, Arabic script narrowed to its candidates — decided by Unicode table before the model ever runs. Then a fixed prior correction (-τ·log(prior), τ=0.75 folded into the bias) so well-resourced languages don't swallow their thin neighbors, and a calibrated abstention signal for genuinely ambiguous input.

Reimplementing it from the docs

The training repo is private, but the desert-ant-core SDK ships the Swift/Kotlin/JS ports with golden test vectors, so the algorithm is fully specified. I wrote ~100 lines of Python following it:

# FNV-1a 32-bit over Unicode scalar values — not bytes, not UTF-16.
# Getting the unit wrong silently shifts every feature.
def fnv1a(s):
    h = 2166136261
    for ch in s:
        h ^= ord(ch)
        h = (h * 16777619) & 0xFFFFFFFF
    return h

# each token gets ^/$ markers, then n-grams of orders 1..5 hashed into 65536 buckets
marked = [0x5E, *[ord(c) for c in token], 0x24]

Then the part that separates a reproduction from a guess: I ran their detection_vectors.json — 19 pinned cases with exact probabilities. 17/19 matched. One miss is Greek, which the script router decides before the model (correctly, in production). The other, "xy", is off by ~2% in probability because their runtime applies discard tables my reimplementation lacks. Honest margin, both explained.

My benchmark: 25 languages, three words each

Their published accuracy is on their data. I wrote 5 three-word phrases per language by hand — 25 languages, 125 cases — covering Germanic, Romance, Slavic, Indo-Aryan, Turkic, Semitic, and Southeast Asian families. Result: 98.4%, with the two misses being Indonesian scored against its near-twin Malay (0.797/0.203 — arguably a draw) and Bengali vs. Assamese.

Latency, measured over 200 runs of my pure-Python reimplementation including the hashing step: p50 3.71ms, p99 5.76ms. That's Python overhead — their native JS runtime reports 0.028ms for a short sentence — but even my slow port clears any real-time budget.

And the abstention design is real, not brochure copy. Feed it "la casa" and you don't get a confident wrong answer, you get Italian 0.305 / Spanish 0.295 — an honest coin flip, exactly what a langid model should emit on text that is genuinely both.

graph TD
  A[raw text] --> B[normalize: lowercase, strip URLs/@tags/digits, 512-char cap]
  B --> C{script router
zero parameters}
  C -->|unique script| D[decided: e.g. Hangul → ko]
  C -->|Latin / shared| E[FNV-1a hash n-grams 1-5]
  E --> F[int8 EmbeddingBag 65536x32]
  F --> G[linear head 59x32 + prior-corrected bias]
  G --> H[masked softmax + reliability signal]

The failure mode worth knowing before you ship

Every polished model has a tell, and Tongue's is very short English. "hi i am" → Welsh, 0.996. Not "likely" — near-certain Welsh. Tiny lexical models have no world knowledge to fall back on, and a two-word English fragment that appears in no training context gets claimed by whichever language's n-grams happen to cover it. Their own README flags short-input fragility in the quantization notes; my test quantifies it. If you deploy this on keystroke-level input, put a length floor on the confidence signal.

Bottom line

This is the correct bet. The industry spent three years routing everything through a frontier API because generalist models were the only ones with good developer ergonomics — one SDK, few lines of code, no tokenizer hell. Desert Ant is selling exactly that ergonomics at 2MB instead of 2GB, for tasks where 98% on three words is all you ever needed. I checked the receipts and they hold. Where it doesn't hold — micro-text, close language pairs — it says so or loses narrowly, not catastrophically. If you're bleeding tokens on a langid, PII-filter, or topic-tag call a hundred thousand times a day, this launch just took your excuse away.

Related