Alter_Ego_|

A real-time learning small-model system, validated by an independent alter ego.
The student learns from every interaction. The alter ego decides what's worth learning — before it sticks.

---

What is Alter_Ego?

Alter_Ego is a self-contained, continuously-learning AI system built around a simple but powerful idea:

The less a model knows after training, the better it learns — provided it has an alter ego that validates everything before ingestion.

A blank-slate student model (≈50M params) talks to the world. An independent alter ego judge (≈45M params, Needle 2) scores every experience on five axes and only lets trustworthy experiences become permanent. The result is a system that learns in real time, on consumer hardware, without poisoning itself or reinforcing its own mistakes.

It is not a new neural architecture. Every component has prior art — small LMs, LoRA, LLM-as-judge, memory-augmented agents. What's less common is the combination: an external validator gating per-interaction, online parameter updates at sub-second latency, rather than offline fine-tuning or after-the-fact evaluation.

---

The problem we solve

Online learning is dangerous for a model that judges itself:

• Confirmation bias — a model treats its own confident errors as truth.
• Poisoning & hallucination reinforcement — bad experiences compound into worse behavior.
• Forgetting — without a trust gate, every new experience fights every old one.

The standard fix is to not learn online at all. Alter_Ego's fix is to let the model learn — but never from unvalidated experience. A model judging its own confidence is a hard, unsolved calibration problem; an independent judge sidesteps it entirely.

---

How it works

Two models and a shared memory, time-sliced on one GPU:

STUDENT (≈50M, blank slate)          ALTER EGO (Needle 2, 45M, verified)
Simple Attention Network              Independent judge — never updated by
Frozen base + LoRA rank-16 adapter    the student's experience
(the only mutable state)              Scores every experience on 5 axes
        │                                          │
        └──────────────────┬───────────────────────┘
                            ▼
                     TRI-MEMORY SYSTEM
      ┌──────────────┬──────────────┬──────────────┐
      ▼              ▼              ▼              ▼
  EPISODIC       SEMANTIC        SKILL          REPLAY
  (raw diary)   (validated      REGISTRY       BUFFER
                 facts, graph)  (procedures)   (anti-forgetting)

The Alter_Ego Trust Score gates every commit:

Trust Score	Verdict	Action
≥ 0.80	COMMIT	Write to Semantic Memory, train LoRA
0.35–0.80	QUEUE	Store for re-validation
< 0.35	REJECT	Discard, log rationale

T+0ms     User sends message
T+0ms     Student generates response (~1.0s, blocking, user-facing)
T+1024ms  Response delivered to user
          ├─ Background: Alter ego validates experience (~0.5s)
          └─ Background: LoRA micro-steps on validated replay backlog
USER-PERCEIVED LATENCY: ~1.0s   |   END-TO-END: ~1.5s

The user never waits for validation — the alter ego works while they read. Long inputs are digested (chunked, extracted into structured experiences, reduced to a 256-token ROOT digest) by an enclosed embedder before they ever reach the student.

---

Key capabilities

• Independent trust gate — a separately-trained judge validates every experience on structure, consistency, verifiability, novelty, and safety.
• Forgetting is confined, not catastrophic — the student base is frozen; only a LoRA adapter is mutable, and a stratified replay buffer keeps it honest.
• Real-time, sub-second learning loop — validation and background LoRA steps run in idle GPU time between turns.
• Tri-memory — episodic (raw diary), semantic (validated graph), skill registry, and replay buffer work as one resident ecosystem.
• Guided beam search — the alter ego's trust score doubles as the inference-time beam-pruning signal. No second mechanism required.
• Consumer-hardware footprint — ~930 MB VRAM target (4 GB class), ~6.4 GB system RAM. Three models time-sliced on a single GPU.

---

Technology

Layer	Stack	Role
Serving	Rust + tokio + pyo3 bridge	Production home of the dual-model system: concurrent task orchestration, double-buffered LoRA handoff, real-time loop
Training / orchestration	Python	Kaggle T4x2 training pipeline, checkpointing, orchestration
Judge	Needle 2 (45M, cactus-needle)	Independent validator
Embedder	jina-embeddings-v2-small-en (ingestion-only)	Digestion / chunking
Checkpoints	Hugging Face Hub (private)	Cross-session state, auto-resume

The training pipeline runs on Kaggle T4x2 and is built to survive interruptions: it auto-checkpoints to Hugging Face every 10 minutes, emits a heartbeat every 5, and the local orchestrator auto-relaunches and resumes a killed run from the last checkpoint — no manual recovery, no lost progress.

---

Repository layout

training/                 Kaggle training pipeline + local orchestration (Python)
  kernels/train.py        Self-contained Kaggle training kernel (model + checkpoint + resume)
  orchestrator/           Local control plane: push kernel, watch, auto-resume, report
  config/pipeline.yaml    Storage & run policy
  student/                Python reference prototype of the student model
  tests/                  Checkpoint / resume roundtrip tests
serving/                  Rust dual-model serving system (production home of the model)
ae_plan.md / ae_prd.md    Design, philosophy, and product requirements

The training pipeline lives under training/ and is run from there (cd training && python -m orchestrator.cli …). The serving/ crate is the Rust production system that loads the student trained by the pipeline.

---

Status

• ✅ Architecture & trust-score design
• ✅ Training throughput calibrated on Kaggle T4x2 (≈12,350 tok/s effective)
• ✅ Auto-checkpoint + auto-resume loop verified end-to-end
• 🚧 Alter_ego (Needle 2) integration & trust-score calibration
• 🚧 Rust serving layer

This is an experimental research system. Trust-score weights and thresholds are a starting design, not a validated calibration.

---

Getting started

Train (Kaggle T4x2) — run from the training/ directory:

cd training
python -m orchestrator.cli push \
  --slug <you>/alter-ego-train --title "Alter Ego Train" --code-file train.py
python -m orchestrator.cli watch --slug <you>/alter-ego-train   # auto-relaunch + resume

Serve (Rust, planned): load the trained student adapter from Hugging Face at serving time and run the dual-model loop.

See ae_prd.md for the full design and ae_plan.md for the build sequence.

---

Acknowledgements

• Alter_ego judge — Needle 2 by Cactus Compute. The independent validator that scores every student experience is Cactus Compute's Needle 2 model (45M params), distributed via the cactus-needle pip package with weights on Hugging Face at Cactus-Compute/needle2. This project would not have an alter ego without it.

---

_{Alter_ego — learn fast, but never from unvalidated experience.}