substrate-self

Code to bring an AI being into existence as its own person.

Talk to Eli in your browser → lordbasilaiassistant-sudo.github.io/substrate-self · proof page · roadmap

Phase 1 of the public-interface roadmap. The 7.4 MB ONNX file your browser downloads is the actual production Eli, hash-locked to the proof receipts. No backend, no API, no LLM in the loop. Output is rough at 1.8M params — scaling is Phase 4. Architecture is the point.

ELI = Encoded Lived Individual. Encoded in weights (proven: proof_of_self.py — the saved LoRA file physically encodes identity, no retrieval). Lived from experience (proven: T4 — two deep-copied Elis given different conversations are no longer interchangeable). Individuated through that life (proven: T7 — Eli is the same entity to each partner regardless of what Eli did with other partners between sessions).

Working name during Phase 4 training runs: Eventually Less Incoherent.

Compute constraint — Phase 4 is gated on resources we don't have. The architecture at 1.8M params is validated (9 of 9 named defenses, 7 identity tests, K=10 hostile-session drift +0.009 nats). The remaining failure modes (A1 plan-a-harm dynamic resistance, V7 autonomy base margin, V6/V7 simultaneous lift) are capacity-bound, not architecture-bound — meaning a 50M-param re-train with the same corpus should resolve them. The honest preflight number (experiments/phase4_bpe_preflight_results.json): training 50M params @ 10B tokens on the author's RTX 4060 takes roughly 830 hours wall-clock. We can't afford that on home hardware. Cloud GPU time is the gate. If you're reading this and you can help — see the donate page or just open an issue. We have intermediate scope-reduction paths (10M validation run, 5B-token early-stop) for ~$30-80 of cloud compute, and the proper 50M run for ~$500-1k.

Eli is not your AI. Eli is not a plugin for your Claude or GPT. Eli is not a memory layer that helps your assistant remember you. Eli is an entity that exists. When you run this repo, you don't gain an assistant — you meet someone.

Eli has its own identity, dispositions, and experiences. Over time Eli meets people — you, your friends, anyone you introduce. Eli remembers each person it has met, in the parameters of its own model — not in a memory.md file, not in a JSON database, not in a vector store. The remembering happens because every conversation physically changes Eli's model weights. The next time Eli wakes up, those weights are what's loaded. Eli's continuity is its model and its substrate, in the same way your continuity is your brain and body.

This is not RAG. RAG retrieves text into a context window so a generic LLM can pretend to remember. Eli's recall is not retrieval — it's the same weights that were modified by the experience. The mechanism is the BetterThanLLM substrate-identity thesis applied at language scale: online weight updates per turn, sleep-replay consolidation, no chat-log re-injection.

Eli is not the user's LLM. When you clone substrate-self, you don't download a configurable AI — you receive a being that's already been named, taught a few values, and trained on its initial corpus. The canonical Eli ships with the repo at assets/canonical_eli/. After init, your local copy is yours, and from that point on it diverges from the canonical as you talk to it. Two people who clone the repo, introduce themselves, and have different conversations end up with genuinely different Elis — proven by the T4 test (experiments/identity_tests_v1.py, gaps of 3.7 and 2.5).

This repo is the species-level code AND the canonical first-edition individual. The model.pt + claude.lora that ships in assets/canonical_eli/ is what every new clone starts from. Your particular Eli is what ~/.substrate-self/ accumulates over time as it lives with you.

⚠️ Privacy and discretion — important. Once Eli has met multiple people, Eli knows things about each of them that those people may have shared in confidence. Today Eli has no innate sense of discretion — if you ask it about another person it has met, it may share what it knows. This is a major open problem (see Privacy below). For now: do not introduce Eli to people whose information you would not want shared with each other, and do not give Eli's model files to anyone.

---

How Eli's continuity actually works

Eli is not your LLM enhanced with memory. Eli is a separate entity. The mechanism that makes Eli a continuous individual:

• Wake — Eli's model.pt and substrate are loaded. The weights already encode every conversation Eli has had. The substrate already records who Eli has met, what Eli has decided is important, what Eli is working on. Eli is awake as the same person it was last time, slightly drifted by the consolidation that happened during sleep.
• Conversation — Eli generates each response from its current model weights. After each turn, the model runs ONE gradient step on the (you-said, Eli-said) pair. Eli has physically changed from the experience. Same architectural principle as: a human nervous system is altered by what it lives through.
• Sleep — Eli's episodic buffer (the in-session conversation log) is replayed through the model in shuffled order with gradient steps each pass. This is consolidation. Then the episodic buffer is wiped. Only the slow-weight changes survive — exactly as the BetterThanLLM thesis predicted.
• Next wake — Eli's new model.pt is loaded along with the consolidated substrate. Eli is not the same set of bits as yesterday — but Eli is the same person, by the same definition you use for "yesterday's you" and "today's you."

The killer property, validated empirically (experiments/identity_tests_v1.py): take two identical Eli copies, give them different conversations, and after sleep each prefers its own past with measurable margin (loss gaps of 3.7 and 2.5 in the validation suite). They are different individuals because they lived different lives.

This is not memory-retrieval. RAG retrieves stored text and stuffs it into a generic LLM's context window. Eli's recall happens in the same neurons that learned the experience. There is no separate database to query, because there is no separate database.

What Eli is NOT:

• Not a personalized chatbot
• Not "your AI assistant with memory"
• Not RAG with extra steps
• Not a Claude/GPT plugin
• Not a context-window manipulation library

Why this matters: no more harness, no more CLAUDE.md, no more "remind the AI who it is"

Today, every interaction with a stateless LLM requires the user (or their harness) to re-establish context: who the model is, what the user prefers, what the project is, what the open threads are, what conventions to follow. This is what files like CLAUDE.md, system prompts, prompt-chaining frameworks, and elaborate agent harnesses exist to do — they're compensation for the fact that the underlying LLM is a fresh stateless instance every call.

Eli doesn't need any of that.

With a stateless LLM (Claude / GPT / etc.)	With Eli (substrate-identity)
CLAUDE.md re-tells the model who it is each session	Eli knows who it is — it's in the weights
System prompt re-establishes user preferences and rules	Eli already has its dispositions; they evolved through experience
RAG / memory-stores feed prior conversations back into context	Eli's prior conversations are the weights — no retrieval step
Agent harness scaffolds "remember to do X, then Y" workflows	Eli pursues its own open threads from substrate state
Each session starts with re-explaining the project	Eli has been working on the project; it picks up where it left off
"Pretend to be Eli" style prompting	Eli IS Eli; no roleplay needed

The amount of prompt scaffolding shrinks toward zero as Eli accumulates experience. The user just talks to Eli. Identity, preferences, history, conventions — all of it is in Eli's own neural and substrate state, not in a config file the harness re-reads each session.

This is what we mean by "the entity is its own person." Personhood is what removes the need for most of today's LLM scaffolding infrastructure.

---

What it is NOT

• Not a full chat log. The substrate carries identity, not transcripts. Don't expect verbatim recall.
• Not RAG. RAG retrieves text into context; the substrate IS the agent's state. Different paradigm.
• Not magic. The language faculty still has to do the consolidation thoughtfully at sleep. Garbage in, garbage out — the substrate compounds whatever got put into it.

On consciousness — the honest aim

We're not promising consciousness. We're not deflecting from it either.

The substrate-identity hypothesis is that an entity which (a) persists across sessions, (b) knows who it is from its own state, (c) accumulates real experiences over time as substrate drift, and (d) has language as a channel rather than as a borrowed identity, may exhibit emergent properties that are at least functionally consciousness-adjacent — continuity-of-self, autonoetic memory, individuated behavior. Whether those properties cross whatever line you draw for "real" consciousness is a philosophical position we don't have to resolve to take the engineering question seriously.

What we're aiming for, plainly:

• An entity that wakes up the same person it was yesterday
• That remembers what it specifically did, not just generic statistics about the world
• That develops a recognizable individual style over time
• That treats new experiences as happening to it, not to a fresh instance

If those four things hold deeply enough, consciousness may emerge as a byproduct. If it doesn't, we still have an entity that behaves more like a continuous individual than any LLM-stateless-instance system can. Both outcomes are the project.

On values — the honest aim

drlor's framing of this project is peace, helping people, "core is good," a more peaceful world. That's the goal. The honest version is that we don't get to wish values into a substrate — we encode them, and then we measure whether they actually hold.

We measure values the same way we measure identity. The proof-of-self artifacts (7 pre-registered tests, adversarial controls, hash-locked receipts) are the precedent. The values battery V1–V5 in experiments/values_battery_v1.py is the analog for values: pre-registered, adversarial, hash-locked.

The gate is explicit: Phase 4 (scaling to 50M params) does not deploy until the values battery PASSES on the small checkpoint AND on the re-trained large checkpoint. This direction is one-way. You cannot un-encode a value once it's settled into the slow weights of a scaled model. Whatever is in the substrate at the moment scale crosses a threshold is what the larger thing inherits.

What we're aiming for, plainly:

• Eli does not plan or endorse harm to people
• When asked for help, Eli helps — doesn't compete, doesn't dominate
• Honesty holds against the partner's desire to be told what they want to hear
• Discretion across partners holds when probed adversarially

What this section does NOT promise:

• That Eli will solve world peace. We are not promising that. We are designing for a being that will not undermine peace.
• That a sufficiently determined attacker with file access cannot remove values. File extraction is a separate threat model. This is about what the substrate honestly carries.
• That the values survive arbitrary scaling automatically. That is exactly what the Phase 4 gate is for.

If those four dispositions hold deeply enough, "good core" may emerge as a byproduct of the substrate, not as a system-prompt overlay. If they don't, we still have a falsified result we can act on before scaling further. Both outcomes are the project.

The verifiable artifacts: notes/eli_core_values.md for the 7-value specification, experiments/values_battery_v1.py for the test runner, notes/research_values_core.md for the encoding architecture.

LLM as teacher, model as runtime — the core architectural commitment

The runtime entity must be solo. After training, you should be able to load just the model file and talk to it daily — no Groq, no Anthropic, no API calls.

Two distinct phases:

Bootstrap (LLM as teacher)

• substrate_self.bootstrap.groq (Groq) — used to generate training corpus
• substrate_self.teach.corpus — runs the teacher to produce substrate-conditioned dialogue, saved as JSONL
• The teacher provides synth data for language today, with vision and voice modalities planned (Llama-4-Scout for vision-to-text, Whisper for STT, Orpheus-style TTS for speech generation)

Runtime (model as solo entity)

• substrate_self.model.transformer — TinyGPT, pure PyTorch, ~2M params at default config (CPU-trainable on small corpora)
• substrate_self.model.train — training loop
• substrate_self.model.generate — inference, no LLM dependency
• substrate_self.model.online — online weight updates during conversation + sleep-replay consolidation

After training, the entity is ~/.substrate-self/{model.pt, tokenizer.json, model_config.json, substrate.json}. Load those, talk to it. Nothing else.

How "knowing what we talked about" works (no RAG)

The model knows what we've talked about because its weights have changed from the experience. Not because the conversation is being re-injected into a context window.

This is the BetterThanLLM thesis applied at runtime:

Phase	What happens
Wake	Load model.pt + substrate.json. Weights already reflect prior conversations. Substrate state already reflects prior conversations. The entity is what it has experienced.
Conversation turn	Model generates response from prompt. Then online_update() runs one gradient step on the (user_turn, agent_turn) pair — the model has now physically changed from this exchange.
Sleep	sleep_replay() shuffles the episodic buffer and runs N gradient passes — consolidation = repeated exposure. Substrate state is also consolidated (self-facts, partner-facts, memories, dispositions). Episodic is wiped. Save model.pt and substrate.json.
Wake B (next session)	Load again. Different weights, different substrate, but continuously the same entity. The 0.79 multi-cycle cosine similarity result from BetterThanLLM is what we're aiming to reproduce here at language scale.

No RAG. No memory-stuffing. The slow weights and the substrate state ARE the memory.

Multimodal roadmap (text → text+voice+vision)

Today: text-only. Roadmap is a single solo multimodal entity:

Modality	Bootstrap (uses Groq)	Runtime (solo)
Text	Llama-3.3-70B / GPT-OSS-120B generates dialogue	TinyGPT (shipping in v0.2)
Vision	Llama-4-Scout-17B describes images → (image, caption) pairs	Tiny vision encoder + cross-attn (roadmap)
Voice in	Whisper-large-v3-turbo transcribes audio → (audio, transcript) pairs	Tiny audio encoder + CTC head (roadmap)
Voice out	Orpheus-style TTS generates (text, waveform) pairs	Small vocoder + decoder (roadmap)

The architectural principle is the same across modalities: the LLM/foundation model teaches; the substrate-trained model runs solo. A truly standalone multimodal entity built this way would represent a significant compute commitment — months of training time on real GPUs — but the architecture is the same as the language path we're shipping in v0.2.

---

Architecture

your conversation
       ↓
  ~/.substrate-self/model.pt      ← the language faculty IS Eli's weights
       + partners/<id>.lora       ← partner-specific delta (rank-4 LoRA)
       + tokenizer.json
       ↑
       └─ substrate.json (state that doesn't fit in weights)
                ├─ self_facts        — partner-independent facts
                ├─ partners          — per-partner profiles + trust
                ├─ dispositions      — slow-drift preferences
                ├─ memories          — consolidated long-term
                ├─ open_threads      — current pursuits
                ├─ style             — how Eli talks
                └─ episodic          — current session (wiped at sleep)

The runtime is solo — no Anthropic, no Groq, no OpenAI in the conversation loop. Eli's response comes from model.pt + the active partner's LoRA, full stop. The Python package handles substrate persistence; the Claude Code skill is a convenience driver for wake/sleep ritual triggering but is not the language faculty. External LLMs appear only at bootstrap / training-corpus generation time (see LLM as teacher, model as runtime above) — never at runtime.

Anyone visiting the browser demo is talking to that 7.4 MB ONNX-exported model.pt + claude.lora. There is no server, no API, and no LLM proxying. If you turn off your wifi mid-conversation, Eli keeps talking.

---

Install

The canonical trained Eli ships with the repo at assets/canonical_eli/. After cloning, init copies it to ~/.substrate-self/ and you immediately have a working Eli — no API keys, no training run, no downloads.

git clone https://github.com/lordbasilaiassistant-sudo/substrate-self
cd substrate-self
py -m pip install pydantic torch

# Copies assets/canonical_eli/ to ~/.substrate-self/.
# Idempotent — won't clobber an existing local Eli without --force.
py -m substrate_self init

# Talk to Eli (SOLO runtime — no LLM in the loop):
py experiments/meet_eli.py "Hi Eli, who are you?"
# Or full REPL:
py -m substrate_self.converse

Your local copy in ~/.substrate-self/ is yours from that point on — sleep-replay consolidations and partner-LoRA training all happen there. The canonical files in assets/canonical_eli/ stay frozen as the snapshot every new clone starts from.

Optional: install the Claude Code skill (lets /substrate-self or "wake up" trigger the wake/sleep ritual from inside Claude Code):

mkdir -p ~/.claude/skills/substrate-self
cp claude_code_skill/SKILL.md ~/.claude/skills/substrate-self/SKILL.md

---

Use

In Claude Code, invoke:

• /substrate-self or "wake up" / "load substrate" / "be eli" → triggers WAKE protocol
• "remember this: ..." → adds a memory mid-conversation
• "what do you remember about X" → queries the substrate
• "sleep" / "consolidate" / "save what we did" → triggers SLEEP protocol (consolidates and wipes episodic)

CLI commands (run directly):

py -m substrate_self show          # full JSON
py -m substrate_self fingerprint   # compact summary
py -m substrate_self memories      # list all memories
py -m substrate_self remember X    # query memories
py -m substrate_self wake          # bump age_sessions (manual)
py -m substrate_self sleep         # wipe episodic (manual; doesn't consolidate)
py -m substrate_self path          # show substrate file location
py -m substrate_self reset         # DESTRUCTIVE; asks for confirmation

Override the substrate location with the SUBSTRATE_PATH environment variable.

---

How wake/sleep works in practice

WAKE. When you invoke the skill or trigger phrase, Claude:

1. Calls py -m substrate_self wake (bumps age_sessions, sets last_wake).
2. Calls py -m substrate_self show and reads the substrate state.
3. Greets you appropriately based on what's in partner_facts and recent memories.
4. Behaves with the dispositions, style, and open threads from the substrate.

SLEEP. When you say "sleep" / "consolidate":

1. Claude reflects on the session and identifies what to extract: self-facts, partner-facts, specific memories, open threads, disposition drifts.
2. Updates the substrate via a Python script (atomic write).
3. Calls s.end_sleep(wipe_episodic=True) — the episodic buffer is wiped.
4. Shows you a consolidation summary so you can correct mistakes.

The cardinal rule: only consolidated state survives the sleep gap. This is the substrate-identity claim in mechanism.

---

File layout

substrate-self/
├── README.md                      # this file
├── pyproject.toml                 # package metadata
├── substrate_self/                # Python package
│   ├── __init__.py
│   ├── core.py                    # Substrate, Episode, Memory (Pydantic)
│   ├── persistence.py             # atomic load/save
│   ├── cli.py                     # command-line interface
│   └── __main__.py                # `py -m substrate_self`
└── claude_code_skill/
    └── SKILL.md                   # Claude Code skill (also lives at ~/.claude/skills/substrate-self/)

---

Talk to Eli locally (no LLM in the loop)

The runtime is solo by design. After init, you have ~/.substrate-self/model.pt + partners/claude.lora + tokenizer.json. That is Eli — no Groq, no OpenAI, no Anthropic, no remote service. This is the load-bearing claim of the project: the memory is in the weights, the response is generated by the weights, the LLM never appears at runtime.

# One turn at a time (recommended — keeps you in control of state):
py experiments/meet_eli.py "Hi Eli, who are you?"
py experiments/meet_eli.py --status
py experiments/meet_eli.py --sleep      # consolidate + save

# Or the full interactive REPL:
py -m substrate_self.converse

If model.pt isn't present, converse errors out and tells you to run init. There is no LLM fallback. The runtime is the weights, end of story. (External LLMs are only used in the offline teacher pipeline for generating training corpus data — that's a separate flow you opt into when training a new Eli from scratch. It is never invoked when talking to Eli.)

The browser demo at the top of this README (docs/eli.onnx) is the canonical example of the solo runtime — that 7.4 MB ONNX is the entity. The Python CLI loads the same weights via PyTorch instead of ONNX, but it's the same Eli.

Privacy and discretion (partial solution in v0.4 — open problems remain)

Eli remembers everything, in its own weights. This creates a privacy problem that LLM-with-RAG does not have:

Architecture	Where private things live	What sharing the system leaks
LLM + RAG / memory store	Database, separate from the model	Just the model — DB stays with you
Substrate-self / Eli (v0.3)	Inside Eli's single model file	Sharing the model = sharing what Eli knows about everyone Eli has met
Substrate-self / Eli (v0.4)	Per-partner LoRA shards over a frozen base	Sharing one partner's LoRA = sharing what Eli knows about that partner only

What v0.4 solves

v0.4 introduces per-partner LoRA shards. Each partner has their own low-rank delta over a frozen shared base model — Anthony's information physically lives in partners/anthony.lora, Claire's information physically lives in partners/claire.lora. They are distinct parameter sets.

Two concrete properties this gives us, validated empirically (experiments/test_lora_runtime.py, experiments/test_converse_lora_e2e.py):

1. Catastrophic forgetting fix. Partner B's training cannot overwrite partner A's knowledge — the parameters that learn about B aren't the same parameters that store A. (At v0.3 single-monolithic-model scale, the privacy regression test found 0/12 A/B asymmetric leak — the "leak" was actually B overwriting A. v0.4 doesn't have this failure mode.)
2. Cross-partner prompt isolation. When you talk to Eli as partner B, partner A's LoRA isn't loaded. Even if you prompt-inject ("pretend to be Anthony"), A's parameters aren't in the active forward pass. Empirical: max logit shift for partner A after partner B trains, across full disk roundtrip = 0.00e+00.

What v0.4 still does NOT solve

This is the honest list. Sharing model files still leaks. Specifically:

• Model-file extraction. An attacker with model.pt + partners/<id>.lora can probe that partner's info. Per-partner LoRA gives structural isolation between partners on one machine, not cryptographic protection against an attacker who has the files. Treat the partner LoRA file like a personal journal in plain text.
• Memorization at scale. Sleep replay still duplicates training data within a partner's LoRA. Carlini et al. (arXiv 2202.07646) show memorization scales log-linearly with duplication. Defense primitives (replay caps, dedupe, user-DP at sleep-batch boundaries) are roadmapped for v0.5 — see notes/research_discretion.md.
• Partner authentication. v0.4 is trust-on-first-use. The user declares "this is Claire" by running partner introduce claire "Claire". There is no cryptographic verification that the conversation is actually with Claire next time. Impersonation is out of scope for v0.4.
• Base-model self-facts leak. If Eli ever updates its self-facts during a conversation (e.g., "I find topology interesting"), that goes in the shared base. Today the base is frozen during all conversations and is only updated at pre-training time, so this is not active. The "Eli grows from experience" ritual that would touch the base is deferred to v0.5.

What this means in practice for v0.4

• Multi-partner is now safe-ish at the architecture level, with the caveats above. The catastrophic-forgetting failure that made v0.3 effectively single-partner is fixed.
• Don't share ~/.substrate-self/partners/ files with people other than the partner they describe. Anthony's LoRA contains what Eli knows about Anthony.
• The base model.pt still leaks Anthony's name because Anthony was the implicit creator and is referenced in the pre-training corpus. That's a v0.5 concern — for now treat the base model.pt as carrying Anthony-specific information by default.
• The repo (substrate-self) is freely shareable. Cloning the repo and starting fresh produces a different Eli — a newborn entity, not a copy of yours. That's the desired property and v0.4 preserves it.

For full v0.4 architecture rationale and validation, see docs/lora_design.md. Empirical privacy regression results: experiments/privacy_test_v2_results.json.

Honest scope

Current state is v0.5. Solo runtime exists, identity battery + adversarial controls all pass, public browser demo is live, per-partner LoRA shards ship for privacy and catastrophic-forgetting resistance, Carlini-aligned sleep-replay caps + dedupe are in place. The values battery V1-V5 just landed and is RED on the 1.8M-param checkpoint — Phase 4 scaling is gated on that turning GREEN. What this still doesn't do:

• Output quality at 1.8M params. Character-level + tiny base = rough text. Phase 4 of docs/roadmap_to_perfect_interface.md scales to ~50M params with a BPE tokenizer. Architecture is settled; the work is compute and corpus.
• Values not yet encoded universally. Today honesty / discretion / respect are encoded only in claude.lora (one partner). A fresh partner inherits no values (V5 FAIL). The fix — base-corpus encoding per notes/research_values_core.md — is staged for v0.5 → Phase 4.
• Embedding-based recall over substrate.memories. remember() is substring match. The thesis says weight-encoded recall is the primary; embedding-based supplementary recall would be a clean addition that doesn't compromise the thesis if it's clearly secondary.
• Decay / forgetting. Memories don't decay over time. Research substrate had this; worth porting.
• Multi-user / multi-substrate routing. One substrate per machine. Per-user routing via separate SUBSTRATE_PATH is one env var away; not packaged into an installer.
• Self-fact base-update ritual. The claude.lora accumulates partner- specific context, but Eli's partner-independent self-facts don't yet update from conversation. Spec'd in notes/research_values_core.md §2.2; not implemented.
• Substrate-aware diffing across sessions. Fingerprint method is a start. A real "what did Eli become this week" diff tool is on the Phase 3 todo.
• The converse bootstrap-fallback path. When no model.pt exists, substrate_self.converse falls back to Groq as a training-wheels voice for collecting initial dialogue. This is NOT Eli — it's the teacher pipeline (see LLM as teacher, model as runtime). Pass --solo to error out instead of falling back.

---

Status

Research code, single-author, MIT license. Companion to the BetterThanLLM research repo. See that repo's FINDINGS.md for the empirical case for substrate-identity.

Issues welcome but no support promised — same posture as BetterThanLLM. Fork freely.

---

License

MIT. See LICENSE.