Table of contents

the garden | the brains | how they are used live | the shared recipe | running a gguf | limits | credits

critters: the brains of critters.garden

critters.garden is skizy's garden of AI creatures that live in your browser. Every creature in it that has a mind is a real, very small language model. Nothing is scripted: a bee gets caught in a web, the ants carry her body home, the hive gets crowded and swarms. The garden itself (plants, weather, who wins a fight) is a plain simulation; the brains only choose what to try, and they write it as a short line with *actions*.

This repo holds all of the garden's brains so far:

• the hive brain: Scintilla the honeybee queen and her workers, several models that read each other's hidden states through a learned link ("neuralese"), never each other's words. The same file as hive/BeeLLM-Hive.gguf in the BeeLLM repo (the md5s match).
• the ant colony brain: a queen and a shared worker like the bees, but the link only works by touch. News walks through the colony one touch at a time.
• the talking critters: one 12M language model per species, with a mood, a name and a quirk, that act out their garden day and answer a visitor. Three are in the garden so far (garden spider, crab spider, snail), all v0, and none of them passes the repetition gate yet: 61-73% of their chat replies are copies of training lines. The next ones are trained from scratch the way Scintilla 2.0 12M (BeeLLM-12M-Mood) was, on a corpus written by language-model agents.
• the garden base: a 12M model pretrained on TinyStories, an optional starting point for a critter (training from scratch may end up better). The v0 critters were fine-tuned from it. Not a critter by itself.

Watch them live at https://critters.garden. Meet the critters one by one, with what each brain is and how it did at its gate, at https://critters.garden/critters; the devlog with progress and screenshots is on the same site. Where the bees alone came from: https://bee.pleroma.nexus/.

Everything here is a hobby experiment with toy models. It hasn't been peer reviewed. Every number below comes from a file in skizy's project folder (the training logs, results.json files and gate transcripts), and each card names its source. Where there is no measured number, the table says so.

---

Every brain in one table

Sizes in the table are the file sizes in MANIFEST.md (with md5s). "live" means the garden at critters.garden runs it today.

The snail's standout lines, unedited from her gate (talking/snail/notes.md): a mollusc, if you're fancy... a snail. shell on, always... · my horns are in. I can't see. · oh no. I'm too slow to run. · no legs. just a foot and some slime... · years? a few winters... I slept through them... · yes. don't tell the lettuce... · bad days end. like dry spells... · birds. don't talk about birds... · I eat slowly. so it lasts... · a thrush tapped my shell. I stayed in. · see you. I'll be right here. slowly... · one foot, two eyes on sticks. best body... · Ptolemy, of the shell...

---

The garden

The garden is a 3D forest clearing in the browser with honeybee hives, ant nests, flowers, spiders, snails, butterflies, birds and a hedgehog. Ground rules, carried over from the neural bees:

1. Real garden biology only. Common European garden species doing what they really do.
2. The world decides facts, brains decide choices. The sim owns physics, food, distance, who wins a fight. A brain writes *lays a trail home* or *hides in the retreat*; the sim decides how it ends.
3. Neuralese only inside a colony. The link joins nestmates. Between colonies and species, signals go through the world: scent on the ground, web vibrations, sight. A spider can't read a bee's mind, but she can feel the web shake.
4. Each species' link works the way its real senses do. Bees share one link inside the hive. Ants link only with nestmates they touch. Spiders have no link at all.
5. Brains think when something happens, not every tick, so the garden can hold hundreds of animals.

How each brain is used live

• Hive brain. Each honeybee colony's queen and a focus group of up to 8 linked workers (the ones near the camera or in the action) are voiced by the hive brain; the rest of the colony follows rules. Scintilla's colony thinks with BeeLLM-Hive (the 50M queen), every other hive with BeeLLM-Hive-small. Several colonies share one model's weights in one Web Worker, each with its own link group, so they can't read each other's minds. A colony thinks when something happens or on a slow heartbeat, out of a fixed lines-per-second budget spent mostly where the camera is.
• Ant brain. Each ant colony's queen and up to 10 workers are voiced by AntLLM-Colony. The link is touch only: a waking ant smells the last finished brain step of the nestmates in antenna reach, nothing newer. Four ants at home (two nurses, a digger, the guard at the door) walk the nest's spots the way the training game did; the visible ants near the camera join the group. Two colonies share the weights and have separate links, which is what makes them strangers to each other.
• Talking critters. The selected critter and up to 6 near the camera think with their species' brain. A species with a talking brain runs it instead of its imitation net. Sense turns run at temperature 0.2 (near-greedy decisions); a visitor can talk to her at temperature 0.8 with up to 8 turns of memory. Her [mood:level] tag drives her face; her first *action* in the species' table becomes her intent; chat replies are words only and never move the sim. Every reply goes through the repeat guard (talking/README.md).

---

The shared recipe

All of these are small Llama-style decoders (RMSNorm, rotary positions, SwiGLU), written out by hand in PyTorch so the same maths could be ported to the plain-JavaScript runtime (hive.js) that runs them in the browser. The JS runtime is checked against PyTorch for every exported file (hive: logits within about 1e-5; ants: 6e-5; talking critters: the same tokens and greedy lines in 41/41 cases).

Colony brains (bees, ants). There was no dataset of bee or ant conversations, so the rules were written as a little game that generates thousands of hive or colony days. Each member is trained only on her own lines. Wherever a line needs something another member knows (which sister was swatted, which flower was danced, which ant is a nestmate), the only way to get it right is through the link: gated cross-attention between the members' residual streams, with a learned null key ("smell nothing"), an output projection that starts at zero, and time stamps (bees) or a touch mask (ants) so nobody can read a line while it's being written. The proof is the eval: the same colonies with the link cut fall to 0% on exactly the rows that need the link, and stay at 100% on a member's own news.

Talking critters (v0). BeeLLM-12M's shape, fine-tuned from an English base:

1. Garden base, once. A 12M Llama in BeeLLM-12M's shape (d 320, FFN 960, 8 layers, 8 heads, vocab 2048) trained on TinyStories-style English, with garden-animal stories and the critter chat format mixed in. 20,000 steps, val loss 1.209. See talking/garden-base/README.md.
2. Per species. Copy the base, fine-tune it on that species' storybook: about 30,000 conversations of garden days (the rule game's senses, answered in hand-written voice pools), visitor chats (about 1,450 phrasings across 25 question kinds, keyword-routed answers), personality turns and junk. Loss only on the critter's own tokens, lr 3e-4, keep the best-val weights (all three v0 brains peaked at step 2,500-2,750, so training stops early).
3. The gate. Fresh seeded samples, unedited, read by hand: garden-day actions must be the rule's and inside her table, never-trained questions must get real answers (about 95 of 106), names must be right, moods must carry, and a measured share of her replies must be new sentences, not copies. talking/README.md has the bar.

The v0 brains learned their corpus by heart. The next critters are trained the way Scintilla 2.0 12M (BeeLLM-12M-Mood) was: from scratch with their own tokenizer, 30,000 steps, on conversations written reply by reply by language-model agents.

The queen's and the critters' voice lines were written by language-model helpers under hard rules and checked by script. Lines that broke a rule were dropped, never fixed.

---

How to run a gguf

None of these run in llama.cpp. They use their own architectures (beehive, anthill, critter), and llama.cpp has no way to run models that read each other. They run in plain JavaScript in the browser at critters.garden, with the runtime web/brains/hive.js from the garden's project. Each card below says what the file holds and how a prompt is built, enough to write your own runtime; hive/README.md has the tensor layout and the kv keys.

All files are read straight: f16 or f32 tensors, no quantisation. The tokenizer is inside each file (tokenizer.ggml.*; the big hive uses an 8,192-piece SentencePiece model, everything else the bees' 2,048-piece one).

Hive (beehive). One file holds the queen, one worker brain, the link weights and the tokenizer. Every bee only sees her own conversation. The queen's prompt is what a visitor says to her (... on a quiet day); a worker's prompt is her number and job plus what happens to her. All the bees' prompts of a day go in together (their hidden states smell each other at each link stage), then each bee writes her reply on her own. Every reply starts with a mood tag.

queen   <- ...
bee 7   <- bee 7, nurse: *a hand swats you*
bee 3   <- bee 3, guard:
bee 12  <- bee 12, forager:

queen   -> [angry:high] BZZT! who hurt bee 7?? girls! GUARD!
bee 7   -> [angry:high] BZZZT! *hurt*
bee 3   -> [angry:high] BZZ! *guards bee 7*
bee 12  -> [angry:high] BZZ! *guards bee 7*

(The prompts and the target lines are the training game's, swarm/game.py. Only bee 7's prompt says she was swatted; the queen's prompt is a quiet .... Her sisters and the queen get the number through the link: 100% of the time with it, 0% without.)

Ant colony (anthill). Same layout, plus anthill.link.touch = 1: a reader smells only the nestmates she is touching, and only their last finished day. An ant's prompt is her number, job and spot plus her own news.

ant 41, forager, far trail: *finds dead bee*
-> dead bee! *lays a trail home*

(next day, a nestmate who touches her on the trail:)
ant 17, forager, trail:
-> *smells dead bee* *follows the trail out*

ant 23, guard, door: *meets ant 41*
-> *antennae on ant 41* nestmate *grooms her*

Talking critter (critter). A plain small LM with no link: worker.* tensors only. Each user turn starts with the critter's card: {Name}, {bold|shy}, {female|male|both}, {quirk}: (the snail's card says both), then either the sim's senses or a visitor's words. The model's reply is [mood:level] a few words *action*. Keep her last 3 turns for garden days and up to 8 for a chat; her mood lives in her own last tag, so keep her replies exactly as she wrote them.

<s> <|user|>Juno, bold, female, loves moths: *daytime* *web shakes: big, buzzing* *hungry*<|bee|>[neutral:low] *waits* *lets it tire*</s> <|user|>Juno, bold, female, loves moths: hi Bob<|bee|>
-> [confused:low] not Bob. I'm Juno. *counts her legs*

Stop at </s>, <|user|> or <|bee|>; cap at 64 tokens; temperature 0.2 for senses, 0.8 for chat; run the reply through the repeat guard. Only the exact quirk strings in each species' GATE.md were trained. The special tokens <|user|> and <|bee|> are ids 3 and 4 in the 2,048-piece tokenizer.

Garden base (Hugging Face). This one is an ordinary LlamaForCausalLM and loads with transformers; the tokenizer is a SentencePiece tokenizer.model. It writes TinyStories-style English and knows the chat format, but it has no species: see talking/garden-base/README.md.

---

Talk to your own critter

tools/ has a small web chat and a Discord bot for talking to a critter you trained (with the critter maker on https://critters.garden/make, or fine-tuned from talking/garden-base). See tools/README.md: copy critter.example.json to critter.json, point it at your model, and run tools/web/app.py or tools/discord/bot.py.

Limits

• The talking critters repeat themselves. Measured on 2026-11-07: they copy 55-82% of their chat replies word for word from their training conversations. Their corpus was built from hand-written line banks, and a model that small learns to recite them. They will be retrained on conversations written reply by reply, the way Scintilla's were.

• Tiny models. They garble a word now and then. The 12M critters sometimes say a clause twice or contradict themselves (that's what the repeat guard is for), and a few of their answers miss the question (the gate files list every miss).

• The rules say what each member should write. The colony brains learned to fetch a missing detail through the link, which is a real thing a learned link can do. It is not emergent communication from scratch, and the eval hives come from the same generator as training.

• Small test sets. A few hundred test hives or colonies per row; some rows have n of 1 to 5. Treat the percentages as rounded. The talking critters' gates are 32 garden days, 44 chats and 106 held-out questions each, read by one person and a rough proxy judge.

• Names. The wolf spider has failed her gate three times, each time on names only: she answered to a name she had learned by heart ("Juniper", then "Jo") instead of the one on her card, and took "hi Bob" as her own name. The fix in the corpus recipe (critter_corpus.py): no real name on more than ~100 cards, 62% of cards get a made-up name, and the names the gate uses are held out of training, so copying the card is the only thing that works. The snail was trained on that mix; in the newer 120-line name probe she got 58 right, 32 wrong, 30 none. The garden spider and crab spider here are still the older run-9 mix (newer probe: 66/35/19 and 54/19/47 right/wrong/none).

• Odd-spelled names get mangled. The 2,048-piece tokenizer cuts names like Wynn, Thimble, Xan or Bramblewick into odd pieces, and the 12M model then says them back wrong (Wyn, Wynie, Thistle, Thousle, Qara, Bramblewill). The snail's name probe showed it on her and on the crab spider alike (Wyn, Thoud, Quean), so it is the model size's limit, not one run's. Plainly spelled names (Juno, Odo, Pickle, Zuzu, Cobweb, Ptolemy) were right every time for the snail. The garden therefore gives critters short, plainly spelled names.

• The workers of the hive were never trained on human messages, so they don't answer you; talk to the queen.

• The garden's clock is not the training clock. Training used colony-wide days; in the garden, brains wake for events at different times. The mapping (an ant's "yesterday" is each nestmate's last finished step) was tested in the sim, not trained.

• The hedgehog has a plan and an action table but no brain yet. Wasps have neither.

• May sting. May bite. The spider is harmless, a bit grumpy maybe.

---

Credits

• skizy (schizophyllume) made the garden and the bees, decided every rule and what to try next.
• Loam, the Claude who builds the garden with skizy, wrote the games, training and evals for the ants and the talking critters, and this card. The hive brain and the neural-bees science are from the BeeLLM repo (built with Claude Opus 5.5).
• The link idea comes from Sauers' neural-pairing twins (Quill & Ember). The queen and the garden base were pretrained on TinyStories.
• Voice lines were drafted by language-model helpers and checked by script.

Live garden and devlog: https://critters.garden · the bees alone: https://bee.pleroma.nexus/ · bees repo: https://huggingface.co/schizophyllume/BeeLLM