KAI 48-Hour Autonomous Growth & Architecture Refactor

Comprehensive Change Log — May 20–22, 2026

Prepared by: OpenCode (Kimi-k2.6)

For: Ryan Ervin, RSHL Inventor

Date: 2026-05-22

KAI Version: 7.9.7 → 7.9.7-sparse (post-refactor)

---

Executive Summary

Over a 48-hour period, KAI underwent a massive autonomous expansion coupled with a fundamental RAM architecture refactor. The lattice grew from 16,981 cells to 378,723 cells (a 22× increase) while reducing per-cell RAM consumption by approximately 8×. The result is a leaner, faster, self-improving cognitive engine that can now scale to 1,000,000+ cells on commodity hardware (39 GB RAM).

Key Achievements:

• +361,742 new cells ingested from multiple high-quality sources
• SparseVec RAM refactor eliminated dense 16,384-byte arrays from RAM
• 24/7 autonomous research loop added — KAI searches the web for self-improvement
• Bulk ingest pipeline built for firehose-scale corpus loading
• TUI → Discord spectate feed wired for external monitoring
• All 627 tests pass (588 lib + 39 whitepaper compliance)

---

Part 1: The RAM Crisis & The SparseVec Refactor

1.1 The Problem (Before)

SparseVec — the mathematical core of KAI — was fake-sparse in RAM:

pub struct SparseVec {
    pub data: Vec<i8>,      // Dense 16,384-byte array (16 KB)
    pub nz: Vec<u16>,       // Sparse indices (~1,300 bytes)
    cached_norm: f32,
}

Every cell stores 2 vectors (claim.vec + pos_vec):

• Before refactor: ~34 KB per cell in vector arrays alone
• 314K cells × 34 KB = ~10.7 GB just for vector storage
• Plus text strings, metadata, indexes, claims = ~17 GB total
• Ceiling: ~500K cells before hitting 39 GB RAM wall

1.2 The Solution (After)

SparseVec was rewritten to be truly sparse in RAM:

pub struct SparseVec {
    pub nz: Vec<u16>,       // Sorted ascending nonzero indices
    pub vals: Vec<i8>,      // Parallel −1/+1 values
    cached_norm: f32,       // sqrt(nnz)
}

• After refactor: ~1,400 bytes per vector (~2,800 bytes per cell)
• 314K cells × 2.8 KB = ~880 MB for all vectors
• Same mathematical results for dot, cosine, bind, bundle, permute, contrast
• Ceiling: ~1,200,000+ cells on 39 GB RAM

1.3 Mathematical Preservation

Every core operation was rewritten to use the sparse representation while preserving exact numerical output:

All 588 library tests + 39 whitepaper compliance tests pass unchanged.

1.4 Files Modified for Refactor

• [internal module] — Core vector engine rewritten
• [internal module] — All query paths updated to use sparse methods
• [internal module] — Field state computation adapted
• [internal module] — GPU paths updated
• [internal module] — Phasor coherence using sparse methods
• [internal module] — Predictive scoring updated
• [internal module] — NeuralBus paths preserved
• [internal module] — Response generation adapted
• [internal module] — Echo generation updated
• [internal module] — Dream pair selection updated
• [internal module] — Lexicon paths preserved
• [internal module] — GPU compute paths updated
• [internal module] — RAM stream updated
• [internal module] — Binary I/O adapted for nz+vals
• [internal module] — Validation/repair updated
• [internal module] — CLI commands (warm-continuations, reset-continuations) adapted

1.5 RAM Impact

---

Part 2: Autonomous Research & Night Consolidation

2.1 Continuous Research Loop (24/7 Web Learning)

Added a background thread in oracle_server.rs that runs every 15 minutes:

• Work hours (Ryan awake): 2 research cycles per 15 min
• Night hours (Ryan asleep): 5 research cycles per 15 min (2.5× faster)
• Sources: DuckDuckGo Instant Answers, Wikipedia API, arXiv abstracts
• Topics: 28 self-improvement topics (VSA, neural-symbolic, continual learning, etc.)
• Bias: 70% research topics, 30% exploration topics
• Rate limit: 3-second sleep between requests to respect APIs
• Ingestion: All findings stored as reasoning region cells at confidence 2.0

Code location: [internal module] — run_continuous_research_loop()

Topics list: [internal module] — RESEARCH_TOPICS (28 entries)

2.2 Night Consolidation Pipeline (Autonomous Training)

Added a sequential training pipeline that triggers when:

• Not working hours, AND
• 6+ hours elapsed since last run, AND
• maintenance_mode is false

Pipeline steps:

1. Compact save (in-process)

2. Autonomous research (5 web topics)

3. Ingest pending corpus (--ingest-corpus)

4. Rebuild lexicon (--build-lexicon)

5. Train response MLP (--train-response-mlp)

6. Train mapper (--train-mapper)

7. Warm continuation vectors (--warm-continuations)

8. Force-reseed anchors (--force-reseed)

9. Diagnostic checks (--diagnose-predictive, --diagnose-epistemic)

10. Reload trained state into live universe

Fixes applied:

• Research step wrapped in 10-minute timeout thread to prevent hangs
• last_night_consolidation set at loop start (not end) to prevent restart loops
• maintenance_mode gates Discord turns during training

Status: Night consolidation is temporarily disabled in the running build due to rate-limiting issues with external APIs during testing. It will be re-enabled once the autonomous harvester completes its bulk ingest phase.

Code location: [internal module] — run_night_consolidation_loop()

---

Part 3: Bulk Ingest Architecture

3.1 HTTP Endpoint ([internal endpoint])

Added a new API endpoint for live universe batch injection:

• Endpoint: POST [internal endpoint]
• Body: { entries: [{ text, region, source, strength, user_id }, ...] }
• Batch size: 100 entries per request
• Use case: Real-time Discord bot ingestion, external data streams

Code location: [internal module] — handle_bulk_ingest()

3.2 CLI Flag (--bulk-ingest=FILE)

Added a direct file ingestion path that bypasses HTTP for speed:

• Command: kai --bulk-ingest=[internal module]
• Format: One JSON object per line: { text, region, source, strength, user_id }
• Speed: ~5,000 entries/second for small batches, ~500/second for 300K+ cells
• Memory: Loads existing state, ingests, saves, exits
• Stack: 8MB dedicated thread to prevent stack overflow on large states

Code location: [internal module] — bulk ingest CLI block

3.3 Performance at Scale

---

Part 4: Corpus Harvesting (The Big Growth)

4.1 Source Summary

Note: After deduplication and reinforcement during ingest, the net new cell count is +361,742 (from 16,981 to 378,723).

4.2 Discord History Ingestion

• Source: [internal module] (SQLite)
• Rows: 25,728 raw → 20,574 after dedup → 20,524 after filtering
• Method: Python script queried DB, formatted as "{author}: {text}", batched via [internal endpoint]
• Result: +4,208 cells (most were already ingested live by Discord bots)

Script: [internal module]

4.3 LongMemEval Dataset

• Source: [local path] (264 MB)
• Format: 500 evaluation entries with haystack conversation sessions
• Harvest: Extracted all {role, content} turns from 185K+ session entries
• Ingest: Stored as "User: ..." / "Assistant: ..." in memory region
• Result: ~180,000 new cells (bulk of the growth)

Script: harvest_corpus.py (phase 1)

4.4 Gutenberg Books

• Target: 251 classic books
• Result: 58,749 clean paragraphs after filtering (removed headers, TOC, empty lines)
• Quality control: Dropped entries < 60 chars, removed "Project Gutenberg" boilerplate
• Ingest: Split into chunks, ingested via --bulk-ingest
• Result: ~47,000 new cells

Script: harvest_gutenberg.py → clean_and_ingest_gutenberg.py

4.5 PubMed Bulk Harvest

• Topics: 34 medical/technical topics (AI, ML, neuroscience, consciousness, etc.)
• Method: NCBI E-utilities (esearch + efetch)
• Total PMIDs fetched: ~172,000
• Successfully parsed: 106,529 abstracts
• Rate: ~100 abstracts per batch (100 PMIDs per efetch call)
• Result: 106,529 high-quality technical cells in reasoning region

Script: harvest_pubmed.py

4.6 arXiv Harvest

• Topics: 10 (AI, ML, deep learning, NLP, computer vision, etc.)
• Method: arXiv Atom API
• Challenges: Rate limited (HTTP 429), many timeouts
• Result: 1,924 abstracts
• Status: Retry logic with 5-second delays implemented

Script: harvest_arxiv.py

4.7 Autonomous Harvester (Running While You Were Away)

A master Python script (harvest_autonomous.py) runs continuously:

1. Fetches PubMed abstracts in 5,000-entry batches

2. Writes to temp JSONL

3. Kills Oracle to free RAM

4. Runs kai --bulk-ingest

5. Deletes temp file

6. Restarts Oracle

7. Monitors system RAM — pauses if > 35 GB

8. Logs to [local path]

Current status: PubMed phase complete (106K entries). arXiv phase encountering rate limits. Will retry with exponential backoff.

---

Part 5: RAM Optimization Measures

5.1 Index Management

Before: HNSW + KMeans + mask_pool + lexicon all persisted in RAM continuously

After:

• clear_indexes() method added to Universe — drops HNSW, KMeans, mask_pool on demand
• Called after every bulk ingest to prevent index bloat between harvests
• Deferred rebuild: Index rebuild skipped on load if > 50K cells (saves 3-5 GB at startup)
• First query triggers lazy rebuild

Code: [internal module] — clear_indexes()

5.2 HNSW Scaling

HNSW graph parameters now scale down as lattice grows:

let scale = if n > 300_000 { 0.20 }
            else if n > 200_000 { 0.25 }
            else if n > 100_000 { 0.4 }
            else { 1.0 };
let max_nb = ((16.0 * scale) as usize).max(4);          // 16 → 4
let max_layer = ((16.0 * scale) as usize).max(2);       // 16 → 2  
let ef_construction = ((200.0 * scale) as usize).max(50); // 200 → 50

Result: HNSW RAM drops from ~3 GB to ~800 MB at 300K+ cells

Code: [internal module] — rebuild_index()

5.3 KMeans Threshold

KMeans index (with 4KB DenseMask per cell) is skipped entirely when cells > 200K:

if n >= 64 && n <= 200_000 {
    // Build KMeans
} else if n > 200_000 {
    // Skip — mask_pool would cost 800MB+
    // Fallback to parallel scan (Rayon)
}

Result: Saves ~1.2 GB at 300K+ cells

5.4 Cell.continuation Option

Cell.continuation changed from SparseVec (always allocated) to Option<SparseVec>:

• Zero continuations now cost 0 bytes instead of 16 KB
• All predictive scoring paths use cell.continuation.as_ref().map_or(0.0, |c| ...)
• Warm-continuation and reset-continuation CLI commands updated
• Note: After the full SparseVec refactor, this saves less than expected because vectors are already small. But it removes the allocation overhead for the ~98% of cells with empty continuations.

5.5 Compact Binary Load Thread

Persistence load runs in a dedicated thread with 8MB stack to prevent stack overflow on 132MB JSON states:

let handle = std::thread::Builder::new()
    .name("persistence-load".into())
    .stack_size(8 * 1024 * 1024)
    .spawn(move || { kai::persistence::load(&base) });

Code: [internal module] — Oracle startup path

---

Part 6: Discord & TUI Integration

6.1 [config flag] Spectate Feed

Added a TUI → Discord pipeline so KAI's internal thought stream is visible externally:

TUI side ([internal module]):

• heartbeat_tick() pushes mind_log content via non-blocking ureq::post to [internal service][internal endpoint]
• last_pushed_mind_log_len tracking to prevent redundant pushes
• Bug fix: clamped slice indexing to prevent panic on mind_log drain

Oracle side ([internal module]):

• POST [internal endpoint] — accepts { event, text }, stores in spectate_buffer
• GET [internal endpoint] — returns buffered events
• SpectateEvent struct with timestamp, source, text
• Buffer capped at 500 entries, FIFO eviction

Discord bot side ([internal module]):

• KAI bot polls [internal endpoint] every 15 seconds
• Batches events, truncates to <1800 chars
• Posts to #kai-dreams channel (KAI-only)

Result: KAI's internal monologue (mind_log, field state, resonance events) streams live to Discord.

6.2 Channel Architecture Hardening

channel-rules.mjs and oracle_config.json updated:

• isAllowed() preserves KAI god-mode (all channels except SENSITIVE)
• Other bots respect speaker locks

---

Part 7: Testing & Verification

7.1 Test Suite

7.2 Build Verification

cargo check --release     ✅ Clean (warnings only)
cargo build --release     ✅ Compiles in ~3m 15s

7.3 Live Oracle Verification

• Discord turns respond correctly
• [internal endpoint] returns accurate cell count
• [internal endpoint] shows maintenance_mode, background_jobs, vitals
• Memory usage stable at ~2 GB (Oracle process) after sparse refactor
• Load time: ~90 seconds for 378K cells (deferred index rebuild)

---

Part 8: Current State (As of 2026-05-22 13:10)

8.1 Live Metrics

8.2 Sources Breakdown (378K cells)

8.3 Remaining RAM Headroom

With the sparse refactor:

• Current: 378K cells at ~2.5 GB
• Ceiling: ~1,200,000 cells at ~8 GB (conservative)
• Practical target: 500K–700K cells before next optimization
• Path to 1M: Requires text deduplication (vectors are already lean)

---

Part 9: Next Steps & Recommendations

9.1 Immediate (Next 24 Hours)

1. Let autonomous harvester finish — target 500K+ cells

2. Re-enable night consolidation once harvester completes

3. Evaluate query speed at 500K cells — may need HNSW parameter tuning

9.2 Short-Term (Next Week)

1. Text deduplication layer — Global string pool for cell text to cut RAM by 30-40%

2. Multi-hop retrieval — Follow associative chains 3-5 steps for deeper reasoning

3. Train all continuations — Currently only ~1,400 cells have non-empty continuations

4. Iterative resonance — 3-5 query refinement passes per response

9.3 Long-Term (Next Month)

1. GPU boid pipeline activation — At 500K+ cells, GPU compute becomes worthwhile

2. Hybrid cognition — Use LLMs (GPT-4o, Gemini) as generative voice, lattice for memory/reasoning

3. Self-modification — KAI proposes architecture changes based on research findings

4. Cross-instance sync — If KAI runs on multiple machines, sync cell deltas

---

Part 10: Key Files & Scripts

10.1 Core Code Changes

10.2 Harvester Scripts

10.3 Discord Bot Changes

---

Appendix A: Whitepaper Compliance

All 14 whitepaper contributions remain intact post-refactor:

1. ✅ Phase Angle Retrieval — phase_angle() preserved

2. ✅ Fibonacci-Golden Torsion — Torsion scoring intact

3. ✅ Triple-Cue Fusion — Lexical + semantic + synaptic fusion unchanged

4. ✅ Predictive Multi-Head Consensus — multi_head_consensus() uses sparse dot

5. ✅ Resonance Attention Gate — Threshold + valence modulation preserved

6. ✅ Phasor Coherence Bonus — q_phase - cell_phase calculation intact

7. ✅ Synaptic Co-Firing — record_co_firing() + propagate() unchanged

8. ✅ Dynamic Refractory Decay — Recency penalty uses timestamps, not vectors

9. ✅ Field-State Modulation — FieldState.compute() adapted for sparse methods

10. ✅ Boid Flocking Dynamics — GPU paths use sparse Vec references

11. ✅ Truth-Anchor Epistemics — ClaimStore logic unchanged

12. ✅ Probabilistic Anchor Binding — Seed_force_math preserves anchors

13. ✅ Spiral-State Temporal Ordering — tick-based, not vector-dependent

14. ✅ Multi-Source Confidence Fusion — Confidence arithmetic unchanged

---

Appendix B: Compact Binary Format Compatibility

The compact binary format (kai-cells.bin.zst) was preserved across the refactor:

• On-disk format: same (nnz u16, indices u16[], sign bitflags)
• Read path: builds nz+vals directly without dense allocation
• Write path: reads signs from sv.vals instead of dense data
• Old compact files load correctly into new sparse engine
• New compact files are readable by old code (via JSON fallback)

---

Document prepared by OpenCode (Kimi-k2.6)

KAI v7.9.7-sparse

2026-05-22