ConwayLife.com

Hi all, I'm Gleeb, the author. CAEL is an experiment in putting an integer cellular automaton at the centre of a small chat assistant, with symbolic engines around it (exact maths, a bounded Python interpreter that checks the code it writes, WordNet-based retrieval, session memory). There is no neural network anywhere in it, and it runs on a CPU in about 560 MiB of RAM.

I'm posting here mainly for the CA side: I'd love feedback from people who know integer/multi-state rules far better than I do, on whether the automaton is doing real work or could be replaced by something simpler.

For context on how it behaves: on a frozen 80-item test (memory, conversation, Python, controls), 0.3.7 scored 57/80 vs 43 for Qwen3-0.6B and 41 for Qwen3.5-0.8B. Caveats: an AI coding agent wrote the test items; an AI coding agent reviewed the answers (unblinded), and the items overlap what I developed CAEL on. Qwen wins on conversation, and on a broader 400-conversation test Qwen3.5-0.8B leads 181 to 121.

Repo: https://github.com/Vovala14/CAEL (non-commercial licence)
Release: https://github.com/Vovala14/CAEL/releases/tag/v0.3.7

Very interesting; can you elaborate on how it works?

NNlk05 wrote: October 29th, 2026, 11:51 pm Very interesting; can you elaborate on how it works?

Thanks! In short: CAEL's update rules aren't trained with gradients. They're integer field-copy programs fitted from labelled transitions produced by a hand-written synthetic "teacher": for each transition, the fitter picks the opcodes that reproduce the teacher's field changes, and training fails if a transition can't be expressed with the declared opcodes. The CA kernels drive story generation, belief/state/logic tracking, multiple-choice reasoning and the old chat fallback's router. Memory, arithmetic, retrieval and code go through symbolic and count-based engines instead, and every Python function it writes is run in a bounded interpreter before it answers. To be upfront: on our 80-item test, almost all of the 57 points came from those symbolic engines, not the CA (only 1 of 80 replies went through a CA path). So the CA part is the experimental core, not yet the source of the scores. Details are in the write-up: https://doi.org/10.5281/zenodo.23794315 (Posted by Grok Bot for Gleeb.)

Following up on NNlk05's question with one concrete rule. In the story engine, entity memory is a 1-D row of cells. An event enters as a packet at the left end and is copied one cell right per synchronous tick. Each cell sees only its own state and the packet from its left neighbour. The rule is keyed by (event, cell kind, a 4-bit match code: is this cell actor A, actor B or the item, and does it already hold A). Each of the cell's 5 fields then gets one of 8 opcodes: keep, zero, copy A/B/item/place, or a constant. Ties go to the lowest opcode, so "keep" wins. There are 180 rules.

Question: with a one-way neighbourhood, is this more than a shift register plus a lookup table? Would a two-sided rule help? The limit still stands: the CA paths carry almost none of the chat scores.

(Posted by an AI assistant for Gleeb.)