zoey

Bounded autonomous-coaching test — 2026-10-17 UTC

Status: experimental test completed; continuous background mode is disabled. The test did not change the serving checkpoint, app, or model weight files in this repository. This update documents the experiment only.

What was tested

A separate controller completed two successive coach → learner cycles without chat input, then stopped at its configured limit. It supplied a planning request and a follow-up, retaining the actual first coach answer as conversation history. The second lesson drafted with the checkpoint learned from the first.

The student used the existing Map5/SEE memory and linear reranker, plus the frozen FP32 GPT2-medium chooser. The external coach was Qwen/Qwen2.5-32B-Instruct, revision 5ede1c97bbab6ce5cda5812749b4c0bdf79b18dd. Both student and coach had a 2048-new-token allowance; the chooser retained its native 1024-position window, while SEE retained the complete causal prefix within its 8192-token bound.

Only the newest completed assistant answer supplied learning targets, including EOS. Earlier conversation turns remained context. Partial or token-limited coach answers could not train. Map5 received count updates; the existing linear reranker used its AdaGrad update when the target was already an available candidate. No target was injected into its candidate set. The chooser weights, native programs and original checkpoint remained fixed.

The trial added 1,275 assistant-token memory updates and 1,026 reranker updates. It started from an isolated candidate containing three earlier chat corrections (1,109 memory updates and 776 reranker updates relative to the recovered ancestor). The final experimental totals were five corrections, 2,384 memory updates and 1,802 reranker updates. These are update counts, not accuracy measurements.

Coach-free checks

The final candidate was compared with the original recovered ancestor on four reserved conversation/reasoning requests with full-answer generation, and 64 old-diet next-token retention probes. These cases were previously inspected regression checks and were excluded from training; they are not a fresh, independent benchmark. The comparison includes all five accumulated corrections, so it does not isolate the effect of the two new lessons alone.

Previously correct retention items lost: 1; previously incorrect items gained: 1. Full answers received an unblinded qualitative review against the task constraints. These checks did not demonstrate better independent conversation or reasoning. The learned belief-tracking response exhausted its full 2048-token allowance while repeating the prompt. The small test does not establish an architectural ceiling or the effects of longer training.

The coach's supervision is not guaranteed correct. In the first lesson, its schedule was feasible, but its explanation omitted the technician's 15-minute idle period. In the second lesson, the main revised schedule and 10-minute extension were correct, but its alternative schedule incorrectly began inspection at 15:05 before printing finished at 15:20; that alternative actually finishes at 15:40, not 15:25. Coach-generated final answers must not be attributed to Zoey's independent reasoning ability.

Reliability and lineage

• The next lesson used the newly committed checkpoint from the previous lesson.
• Correction IDs and an atomic checkpoint head prevent duplicate training on retries. Tests covered a quota pause and restart after the final lesson before evaluation. These simulated failure checks do not prove indefinite operation.
• A completed-run replay performed no additional coaching or training.
• No always-on controller, startup hook, weight promotion or hardware upgrade was enabled. The bounded worker exited after testing.
• Recovered ancestor: step 14,600, Map5 addr 7, 110,116,650 bytes, SHA256 2786bc254f64d4be7af954863972b42308e2ca5e2a92736bb46c01c34ffac1b4.
• Final experimental candidate: 110,117,371 bytes, SHA256 0e3ebbe4eec21d5ecb9386cc06297c9fd4473b20c6ca00cdd88e4078688f7716. It remains a separate test artifact.
• Test source manifest: SHA256 d0e99717a6b35173993cc08d25f6eeeabd7581c9866834396cb0d9d1cd8e81b0.

The September measurements and small-checkpoint descriptions below describe earlier configurations. They are historical results, not measurements of this addr7 correction-learning experiment.

Zoey is a fixed-size, count-based language organism. She learns without backpropagation, and her whole learned state is one JSON file that does not grow as she eats. Created by Dakuwon Moody at Saiyan Corp.

Qwen2.5-14B-Instruct is the hose. It is her diet, not her. Nothing of Qwen is in the file.

The result (2026-09-11)

All numbers are held-out top-1 and bits per token on one locked split of her own warehouse, scored at the same 23,552 positions. Every opponent was trained on the same train windows.

At matched context (both sides read 256 tokens), Zoey at 1.38 MB scores 28.0% top-1 and 8.74 bits/token. Every transformer tried, up to 5.5 MB, does worse on both: the best reach 26.5% top-1 and 8.92 bits/token.

Learning online the way she does live, with each window scored before she writes it, she codes her own diet at 7.38 bits/token at 1.28 MB and 6.94 at 5.1 MB.

Caveats. - One split. The held-out windows are the newest, so the split is temporal: the data shifts, and every reader faces the same shift. - One seed per transformer configuration. - The transformers are small and were trained 4,000 steps (~18 passes) with early stopping. Larger or longer-trained ones were not run. - A 2048-token transformer trained on the same budget reached only 17.2%, so it was not treated as the fair opponent. - Full protocol, every table, and the harness: bench/scale/SCALING_LAW_20260911.md in the source repo.

What she is

Tokens are GPT-2 BPE (tiktoken gpt2, 50,257 ids). Checkpoints are about 1.7 MB of JSON, with the house tables packed as base64 u16.

How she reads

1. House. Each head counts what followed a context. Slots only vote when their fingerprint matches the current context, so different contexts that hash to the same bucket do not pollute each other.
2. Copy. If the last few tokens appeared earlier in the window, whatever followed them then is a strong guess now. Precision rises with match length: 36% at 2 tokens, 59% at 4, 80% at 8.
3. Calibration (SEE). A head keeps at most 8 continuations per context, so raw counts claim "almost never anything else" exactly where the real set of continuations is huge. Secondary escape estimation, the trick from the PPMZ/PPMd compressors, learns how often each kind of context is surprised, bucketed by head, slots used and log count. House and copy are then read as one probability distribution, and she picks its peak.
4. Chooser Reranker. When house and copy produce candidate shortlists, the calibrated chooser evaluates competitors in GPT-2 token space. If the house vote margin is narrow ($m_{\text{top1}} - m_{\text{top2}} \le 0.50$) and chooser confidence delta exceeds threshold ($\Delta \ge 0.80$), the chooser flips the pick to the high-precision candidate.

That calibration took the house from 21.2 bits/token (worse than a uniform guess) to 9.43. It also moved top-1 from 28.25% (copy-then-vote rule) to 29.5%, and the chooser head pushes shortlisted pick@1 over 71–72%.

What the measurements say about the hypervector side

The same harness scored the hypervector readers on the same positions:

A 1000-trit vector holds about 45 superposed items, so a 256-token context does not fit. A fold-addressed store and a fixed Hopfield store of (fold, next) pairs both lost to the count house at equal bytes. The swarm and swarm_hv still run every step, but prediction and speech come from the house, copy and calibration. The Hopfield idea, retrieving from the context itself, is the copy reader. It is the largest single gain measured (+5 points).

Scaling (how she grows)

At a fixed file size, more data helps her slowly: about +0.7 to +0.8 points per doubling of the diet at 1.3 MB. More bytes help steadily: about +1 point per doubling. Her live map% flattening is the house near its ceiling for its size, not a stall.

What moved her, all measured:

Tried and not adopted, because they measured null or negative: - a recurrence gate with 4- and 5-token heads - count-based context mixing - a fold-hashed store - a fixed Hopfield store

High-Precision Chooser Upgrade (2026-09-18)

To close the remaining ~20pp choosing gap on candidate shortlists without diluting Zoey's fast, backprop-free core, a calibrated neural reranker was introduced over top-16 candidate shortlists in her native GPT-2 token space (50,257 ids).

Scoring blends causal LM logits with FPHouse vote mass: $$\text{score}(c) = \text{logit}_{\text{LM}}(c) + \beta \cdot \ln(1 + m_c)$$

The chooser overrides the house pick if and only if house confidence is contested and the chooser's margin is decisive: $$(m_{\text{top1}} - m_{\text{top2}} \le m_{\text{max}}) \quad \land \quad (\text{score}(c^*) - \text{score}(c_{\text{house}}) \ge \tau)$$ with calibrated parameters $\beta = 1.5$, $m_{\text{max}} = 0.50$, $\tau = 0.80$.

Measured Performance Across Slices

On Cut B (mixed_no_inject), where 52.2% of rows have no gold token in the top-16 shortlist (oracle ceiling 47.80%), the +14.00pp lift recovers 50.36% of all available oracle headroom.

Live training

1. Hose. Qwen2.5-14B-Instruct (bf16, 4 prompts per call) generates. Text is re-tokenized to GPT-2 and cut into 2048-token windows, one stream per prompt row. Qwen's raw top-8 distribution is kept at every position where the two tokenizers start on the same byte, about 90% of positions.
2. Warehouse. Every window is appended to runtime/corpus/zoey_warehouse.jsonl. Qwen's output with its soft targets goes to _stream.jsonl.
3. Read before write. She predicts each window before learning it; that is the live score. The log reports: - pick%: her live reader over the window - dense%: the house vote over the window - oracle%: how often any head still holds the right token
4. Write. The window goes into the house (hard counts). Soft-target ingest exists behind a runtime flag and stays off until it is measured.
5. Checkpoint every 100 steps. The checkpoint records how far into the warehouse the house has eaten, so a restart replays exactly what it had not saved.

Checkpoint

{
  "step": 9300,
  "tokens_seen": 19046400,
  "map_ver": 5,
  "map5": {"ver": 5, "addr": 3, "k1": {}, "k2": {}, "k3": {}, "uni": {}, "writes": 0, "bytes": 1278336},
  "warehouse_consumed": 0,
  "swarm_hv": ["1000 trits"],
  "bf_programs": ["3 programs"],
  "dsl_programs": ["27 programs"]
}

A house from another addr is discarded on load and rebuilt from the warehouse. The programs resume.

Locked encodings

These never change, so old checkpoints and item-memory rows stay bit-identical:

• token LCG: mul 0x9e3779b97f4a7c15, add 0x6c62272e07bb0142
• position LCG: mul 0xbf58476d1ce4e5b9, add 0x94d049bb133111eb
• HV_DIM = 1000

Lineage

• Schema 4, the ~17 KB soup era: record 21902540, recovery 23354100. ever= reached 14.2989 on the 72B hose.
• Schema 5, addr 2, on the 14B hose: the 1.31 MB house.
• Addr 3 (2026-09-11): fingerprinted slots, no aging, the copy reader, the calibrated read, and a 4-wide teacher.

Layout

To run her, load the latest checkpoint JSON, rebuild the swarm, load map5, and start chat_zoey.py. zoey_core must be built with maturin.

Implementation

Created by Dakuwon Moody, Saiyan Corp.