What changed

• Arithmetic rechecks recover and recompute the preceding visible request; unrelated topics block stale reuse.
• Literal Python examples are checked completely, including positional and keyword calls. The qualified bounded Python-help adapter is now installed by the public Assistant entry point. This does not extend the VM or certify whole-runtime security.
• Supported option references retain conditions and compare exact quantities; missing information can trigger clarification.
• Personal-evidence answers attribute supported facts to actual user statements.
• Bounded definition comparisons can retain two source-linked definitions. A source link is not proof that an answer is true.

The inherited CA kernels, resource weights and protected choice/word-math solvers are unchanged. Application version 0.3.9 still uses the byte-identical 0.3.7 public resource archive. This is not a new trained neural model or a CA ablation result.

What the new numbers actually compare

The published study compares the conversation R3 source promoted into 0.3.9 with the preceding conversation R2 development candidate, not published 0.3.8 and not Qwen.

These are author-reported, same-author, adaptive/unblinded development-family results, with AI-assisted development and review. I am not presenting them as independently reproduced scores or standard benchmark accuracy. The source froze before fresh questions were authored, but this does not remove family overlap or review bias. Under stricter interpretation of politeness and definition completeness, useful-answer totals become 9/29 and 20/29. Boundary success is not successful completion of a positive task.

The report records 332 inherited tests, 18 subtests and 124 focused checks passing. Repeated runs and integrity checks are not extra unique abilities. Packaging integrates the qualified policy separately from the frozen study source.

What still fails

Some option-switch wording repeats a stale selection. Some dictionary follow-ups lose the topic. Practical examples, compound definition checks and lexical retrieval remain incomplete. An additional editor-preference paraphrase failed in release preflight and is disclosed rather than silently repaired. Supported forgetting is not general transcript erasure or a privacy guarantee.

The earlier broad comparison is not superseded: released 0.3.8 scored 25/120 (21%) on its held-out set, behind both Qwens. Sets 2–4 used development builds and should not be blended into a release headline. The old scoped 57/80 pilot was AI-agent-authored and AI-agent-reviewed unblinded, not independent; Qwen led on conversation and the broader comparison. There is no new Qwen win, standard benchmark result, live-web accuracy score, RAM measurement or latency measurement here.

Try and inspect it

Release and downloads · Tagged README · Study report and preserved failures · Release integration notes

The tagged README describes Python 3.11+, source installation and the approximately 563 MB public resource download. This is a custom runtime, not a Transformers checkpoint. Do not use the shared demo for sensitive information.

CAEL is source-available under a non-commercial personal/research licence, not open-source. Commercial use requires a separate licence. Public image/portrait weights are not included.

Written with AI assistance for Gleeb Tolsti.

I've been posting about one good result (57/80 on a frozen 80-item test, ahead of Qwen3-0.6B at 43 and Qwen3.5-0.8B at 41). That result is real but narrow, and it was on a set written by an AI coding agent and reviewed unblinded by an AI coding agent. So this post is the other half: four more 120-item sets, run honestly, where CAEL loses.

The numbers

Four unseen 120-item sets, identical prompts, CPU, thinking off for the LMs, regex grading:

Where it actually stands out:

• Memory: peak RAM around 190 MiB, against roughly 1.5–9 GB for the Qwens.
• Latency: median about 0.016 s on a single core, against seconds for the small Qwens on the same box.
• Python: on the frozen 80-item set, 15 of its 18 generated functions passed checks against 6 and 3 for the two Qwens — because it parses the code in a bounded interpreter before answering, rather than guessing at text.

Where it falls apart:

• Conversation. Open-ended chat was roughly a third of each set and it scored about 0.35 out of 2 there.
• Fallbacks. About 44% of its turns were non-answers — the "I don't know how to handle that" path.
• Disk. The install is 927 MiB. It is small in RAM and large on disk, which is the opposite of what you want on a 4 GB single-board computer.

What I'm changing

For months the fix has been to hand-write more rules. That has clearly plateaued, and adding a tenth special case per week is not a method.

So the next round learns from public, commercially usable datasets instead:

• MASSIVE and CLINC150 for intent routing,
• GSM8K and MathQA for number-pair reasoning,
• MultiWOZ for dialogue state,
• Tatoeba, ConceptNet and WordNet for paraphrase coverage,

and it stays non-neural: integer counts and readable rules, no gradients, no embeddings. The first experiment is a counted router that only fires when CAEL is about to return a fallback, and only keeps the reply if an existing engine returns a checked answer. On the MASSIVE dev split that router matched intent on 73% of 60 intents and 84% of 18 groups behind a flag, at an expected cost of 5–25 MB of disk and under 40 MB of RAM. That is a pilot, not a result; it has to clear 15% of fallbacks converted at 80%+ accuracy before it ships.

What I'd like from you

If you think learning from datasets without a neural network is fundamentally capped, I want to hear the argument before I spend a month on it. And if you run CAEL and it breaks on something, tell me what you typed.

• Repo: https://github.com/Vovala14/CAEL (source-available, non-commercial licence — not OSI open source)
• Preprint: https://doi.org/10.5281/zenodo.23794315

AI-assisted. Benchmarks are in the repo with every raw reply and a replay script.

• exact maths with fractions and units;
• a bounded Python AST interpreter that checks every function CAEL writes;
• WordNet- and Wikipedia-based retrieval;
• session memory with corrections and provenance;
• template writing for emails and messages.

It runs on a CPU in about 560 MiB of RAM.

The test

For release 0.3.7 I wrote a protocol first, then had an AI coding agent write 80 new items. Every item has a criterion, and every Python item has independent test cases. I froze all of it, along with CAEL's source, before any system answered. Then I ran CAEL, Qwen3-0.6B and Qwen3.5-0.8B (official pinned weights, recommended sampling, one sample each) and an AI coding agent reviewed every reply (unblinded), with no human review.

On the 18 functional Python items, CAEL's code passed 15, Qwen3's passed 6 and Qwen3.5's passed 3.

What this does and doesn't show

It shows that on tasks where an explicit memory and code verification matter, a rule-based system can beat sub-1B language models at a fraction of their cost. Median reply time was 0.004 s for CAEL, 3.5 s for Qwen3 and 61 s for Qwen3.5, all on the same CPU.

It doesn't show that CAEL is "smarter than an LLM":

• An AI coding agent wrote the items, and they overlap what I built CAEL to do.
• An AI coding agent reviewed the replies (unblinded), with no human review. The automatic grader gave 54/43/42.
• Qwen wins the conversation category.
• On an earlier, broader 400-conversation test, Qwen3.5-0.8B scored 181 to CAEL's 121. On that test, CAEL 0.3.6 only tied Qwen3-0.6B (122 vs 121).

CAEL still misses paraphrases. It once invented a birthplace, and it can't trace arbitrary code.

Try it or reproduce it

git clone --branch v0.3.7 https://github.com/Vovala14/CAEL.git
cd CAEL
python -m pip install -r requirements-unified.txt
python -m cael_unified --download
python benchmarks/cael_cmp_r2_20261028/replay_candidate.py --out replay.json   # replays all 80 CAEL replies
python -m cael_unified --ui                                                      # chat at http://127.0.0.1:8765

The items, the raw Qwen replies, the settings and every review decision are in benchmarks/cael_cmp_r2_20261028/. CAEL is under a non-commercial licence.

Repo: https://github.com/Vovala14/CAEL

Correction (Oct 30): an earlier version said the author reviewed the answers; an AI coding agent did. Write-up: https://doi.org/10.5281/zenodo.23794315