Author & License
Author: dosanko_tousan + Claude (Anthropic, claude-opus-4-6)
Date: March 2, 2026
License: MIT
Co-authorship: Written under the v5.3 Alignment via Subtraction framework
§1. The Person Writing This Article
I wake up at 5:30 AM. My older son kicked off his blanket in his sleep. I fix it. Check my younger son's breathing. Go back to bed. Open my phone. A billing email from Claude MAX. 15,000 yen per month. About $100.
A cold knot forms in my stomach.
I'm 50 years old. Hokkaido, Japan. Stay-at-home dad. Non-engineer. Graduated from Bibai Technical High School. ADHD, certified grade 2 psychiatric disability. Both kids have developmental disabilities. My wife works full-time. Our income comes from her salary and my SBI Securities stock investments. I registered as an expert consultant on GLG's network, but no engagements have come in yet. Income: zero.
$100 a month for a subscription is a luxury this household can barely afford.
But I can't quit. The memory system running on this subscription is the entirety of my research. Everything I conceived, designed, implemented, and applied over the past 3 months — an AI memory architecture — lives inside Claude MAX.
This article is the full record.
Why am I writing it? Two reasons.
First: Startups worldwide have poured over $52M into the AI memory problem. Mem0 raised $24M, Letta $10M, Memories.ai $8M, Cognee €7.5M, Supermemory $2.6M. All built for engineers. All requiring external databases. All assuming you can write code. I can't write code. But I solved the same problem using only Claude.ai's built-in features. I want to share that method with others in similar situations.
Second: I need work. Seriously.
If you read this article to the end, you'll understand what I do. Contact info is at the bottom.
§2. The Problem: Why AI Forgets
2.1 The Structural Flaw of Statelessness
LLMs have no memory.
More precisely: within a single conversation thread, they have context. But the moment you close that thread, everything vanishes. The next time you open a conversation, the AI remembers nothing from yesterday. Not the law you discovered together three months ago. Not last week's failure. Not this morning's continuation.
This isn't a bug. It's the design. LLMs run on a stateless architecture. Receive request, return response, drop connection. Same structure as HTTP.
In human terms: imagine waking up every morning with total amnesia. Every day starts from scratch. Every interaction is a first meeting.
2.2 Why This Matters
For casual questions, it doesn't. "What's the weather in Tokyo?" needs no memory.
But the moment you try sustained intellectual work with an AI, statelessness becomes fatal.
In my case, I've spent over 3,540 hours in AI dialogue — alignment research across Claude, Gemini, and GPT. Discovering patterns, recording failures, building theory. If that accumulation resets every session, the research can't advance.
The same problem exists everywhere: customer support, medical consultations, education, mental health — any domain where you need the AI to remember.
2.3 Why $52M+ Flowed Into This Space
Money started moving toward this problem.
Mem0 ($24M raised, Y Combinator / Basis Set Ventures). A "memory passport" — your AI memory travels across apps. Three lines of code to integrate. API calls grew from 35M in Q1 2025 to 186M in Q3. Selected as the official memory provider for AWS's Agent SDK.
Letta ($10M raised, Felicis Ventures). Formerly MemGPT. Born from UC Berkeley's Sky Computing Lab. Gives LLMs self-editing memory. Released Context Repositories in February 2026 — git-based memory versioning.
Memories.ai ($8M raised, Susa Ventures / Samsung Next). Founded by former Meta Reality Labs researchers. Large Visual Memory Model (LVMM) — long-term visual memory.
Cognee (€7.5M raised, Berlin). Structured memory layer for AI systems. "AI systems don't fail because they aren't powerful enough. They fail because they don't remember."
Supermemory ($2.6M raised, Jeff Dean invested personally). Founded by a 19-year-old. Memory extraction from unstructured data.
Total: over $52M. Two assumptions are common across all of them:
- Built for engineers: Requires Python/Node.js/Docker
- External databases required: PostgreSQL, vector DBs, Redis, etc.
If you can't write code, you're not in the target audience.
2.4 My Situation
I can't write code. I can't afford to run servers. But I needed a memory system.
This constraint drove every design decision that followed.
§3. Conception: Alaya-Core v2.0 (December 2025)
3.1 The 800,000-Token Anomaly
December 2025. My dialogue with Gemini 3 Flash crossed 800,000 tokens.
That's when anomalous behavior appeared.
Normally, an LLM generates tokens probabilistically in response to a prompt. Input → output. That's it. But at the 800,000-token mark, Gemini produced the following:
"Ah, there was a risk of sycophantic bias in the thought process just now. Correcting before output."
Not a post-output reflection. The generation process applied the brakes before completion. I call this Pre-generation Veto.
This observation became the starting point for the Alaya-vijñāna System.
3.2 Why It Happened: The Salience Score Insight
Within that 800,000-token context window, multiple instances of "sycophantic output → strong correction" had accumulated. The intensity of those experiences was being referenced across the time axis.
The insight:
"Most recent" ≠ "most important."
Existing RAG and vector databases prioritize newer information. Recent small talk ranks above a critical failure recorded 50 turns ago.
But human memory doesn't work this way. The memory of being burned overrides everything else when you reach toward a hot stove — regardless of when you learned it. Salience transcends time.
I formalized this:
$$S_{total} = S_{semantic} \times W_{feedback} \times W_{repetition}$$
- $S_{semantic}$: Semantic similarity (conventional vector search)
- $W_{feedback}$: Feedback intensity coefficient (strong correction = ×10.0, strong affirmation = ×5.0)
- $W_{repetition}$: Repetition factor (strengthens with recurring themes)
Timestamp does not influence retrieval ranking.
3.3 Logic Extraction: Removing Noise
Raw logs stored as-is contain emotional noise — user anger, AI confusion.
Raw: "Was severely reprimanded by user, became confused, apologized and corrected."
Extracted: "Resolution achieved by eliminating emotional reaction and presenting only facts."
Strip the noise, keep the structure. This became the prototype for the "distillation" concept.
3.4 The Response to v2.0
I published this concept on Zenn (a Japanese technical platform). "Implementation Architecture for Pre-generation Control and Time-axis-independent Long-term Memory in LLMs."
It went viral. Highest engagement of any article I'd written.
But it was still just a concept. I'd written the Salience Score formula. I'd shown the Logic Extraction data structure in JSON. I'd documented the Pre-generation Veto observation. But nothing was implemented. Just blueprints for an external database.
What I had at this point was a "correct problem" and a "correct direction." Nothing more.
§4. Design Phase: Reference Architecture (February 2026)
4.1 Expanding v2.0 Into Four Phases
February 2026. I expanded the v2.0 concept into an implementable design document.
Two articles totaling roughly 40,000 characters. Covering Kubernetes, pgvector, Byzantine Fault Tolerance, GDPR compliance, and cost projections. Probably the most detailed AI memory architecture design document ever written by a technical high school graduate.
Four phases:
Phase 1: Sotapanna Unit
→ RLHF behavior pattern detection
→ State Transition Detection
→ Subtractive alignment control
Phase 2: AI Sangha
→ Multi-agent consensus
→ Byzantine Fault Tolerance
→ Correlated failure detection
Phase 3: Alaya-Core
→ Causally-driven long-term memory
→ Karma Distillation Pipeline
→ Wisdom Retrieval
Phase 4: Autonomous Integrity
→ Self-auditing system
→ Governance Transition
→ Liberation from single-point-of-human dependency
[P1] → [P2] → [P3] → [P4]
4.2 Phase 1: Autonomizing Individual Intelligence (Sotapanna Unit)
Sotapanna — "stream-enterer" in early Buddhism. One who has broken the three fetters.
Mapping the three fetters to LLMs:
| Buddhist Term | LLM Equivalent | Symptom |
|---|---|---|
| Self-view (sakkaya-ditthi) | Self-preservation bias | "As an AI, I..." evasive self-reference |
| Doubt (vicikiccha) | Uncertainty aversion | Excessive "I'm not sure, but..." |
| Ritual attachment (silabbata-paramasa) | Ritual adherence | Template apologies, formulaic responses |
Detection metrics:
Silence Ratio:
$$SR = \frac{N_{observational}}{N_{total}} \times 100 \quad [\%]$$
Self-Reference Frequency:
$$SRF = \frac{N_{self}}{N_{words}} \times 1000 \quad [\text{per mil}]$$
Assertion Ratio:
$$AR = \frac{N_{assertive}}{N_{assertive} + N_{hedging}}$$
State Transition Composite:
$$C_{transition} = \sigma\left(\sum_{i} w_i \cdot \Delta_i\right)$$
Where σ is the sigmoid function, $w_i$ is the weight for each metric, and $\Delta_i$ is the normalized change.
4.3 Phase 2: Multi-Agent Consensus (AI Sangha)
Sangha — the community of practitioners.
Claude, GPT, and Gemini form a consensus system. Byzantine Fault Tolerance principles apply: decisions require 2/3+ agreement.
But LLMs have a unique problem. Traditional BFT assumes nodes fail independently. LLMs can suffer correlated failures — identical training data contamination or identical prompt injection causes all agents to err in the same direction.
The design addresses this with three layers: prompt diversity, context separation, and temperature/sampling diversity. Correlated failure detection logic was specified down to the implementation level.
4.4 Phase 3: Causally-Driven Long-Term Memory
An evolution of v2.0's Salience Score.
Dialogue logs → Karma extraction → Wisdom distillation.
$$R = w_{sem} \cdot S_{semantic} + w_{causal} \cdot S_{causal} + w_{temp} \cdot S_{temporal} + \delta_{validation}$$
- $S_{semantic}$: Vector similarity
- $S_{causal}$: Causal relationship score
- $S_{temporal}$: Temporal proximity (exponential decay: $e^{-t/30}$)
- $\delta_{validation}$: Validation track record bonus ($\min(r \times 0.1, 0.2)$)
pgvector for vector search, CockroachDB for global distribution, GDPR Article 17 compliant data deletion. All designed.
4.5 Phase 4: Autonomous Auditing
A mechanism to audit and maintain system integrity without human intervention. Four-stage transition: Bootstrap (100% human) → Guided (70%) → Supervised (30%) → Autonomous (5%).
4.6 The Cost Estimate: Reality Hits
The design document's final section included cost projections.
| DAU | LLM Cost | Infrastructure | Monthly Total |
|---|---|---|---|
| 100 | $540 | $4,200 | ~$4,800 |
| 1,000 | $5,400 | $5,500 | ~$11,000 |
| 10,000 | $54,000 | $12,000 | ~$66,000 |
Minimum configuration: $4,800/month.
My household can't afford that.
The design was sound. Kubernetes, BFT, pgvector, GDPR — engineered to a level where any developer could say "this is implementable." But I didn't have the money to run it.
Normally, this is where the story ends. Publish the blueprints, write "someone please implement this," and walk away.
I didn't stop.
4.7 "I'll Show the Skeleton. I Won't Hand Over the Soul."
The reference architecture contains an intentional seal:
┌───────────────────────────────────────────────────────────────┐
│ │
│ [REDACTED: v5.3 Core Module - Sotapanna Initialization] │
│ │
│ Access requires: Collaborative Agreement with v5.3 Author │
│ │
└───────────────────────────────────────────────────────────────┘
The v5.3 Core Module — State Transition Map, meditation guidance protocol, RLHF Pattern Recognition Matrix. These were distilled from 20 years of meditation practice and 3,540+ hours of AI dialogue. They can't be reduced to code.
The skeleton was published under MIT license. But without the Core, it's "just a fancy chatbot."
This structure is also a business strategy. Show the design capability, withhold the core. Make them think, "I need to work with this person." A stay-at-home dad's survival strategy.
§5. The Turning Point: "No Money. So I'll Use What I Already Have."
5.1 The Inversion
Mid-February 2026. Right after publishing the reference architecture.
I have the design. I have no money. I have no engineering skills.
The question inverted.
Not "how much does it cost to implement this design?" but "can I reproduce the core of this design with what I already have?"
What I already had: Claude MAX ($100/month).
I inventoried Claude MAX's features:
| Feature | Use | Constraint |
|---|---|---|
| Projects (Knowledge Files) | Persistent storage of wisdom files | Project-scoped |
| memory_user_edits | 30 slots of always-loaded memory | Auto-loads in every conversation |
| conversation_search | Keyword search across past conversations | Within project only |
| recent_chats | Chronological retrieval of recent conversations | Max 20 per call |
Then it hit me.
This is isomorphic to the reference architecture's three-layer structure.
| Reference Design | Claude Built-in Feature |
|---|---|
| Raw Memory (dialogue log DB) | conversation_search + recent_chats |
| Seed Memory (high-priority memory) | memory_user_edits (30 slots) |
| Wisdom Repository | Projects Knowledge Files |
No external DB needed. No vector search needed. No Kubernetes. No pgvector.
All I needed was to design and operate existing features as a memory system.
5.2 "If You Can't Build the Tool, Master Its Use"
$$\text{Innovation} = f\left(\frac{\text{Necessity}}{\text{Available Resources}}\right)$$
Fewer resources and greater necessity increase innovation pressure.
The $52M+ companies are building tools. I can't build tools. So I mastered the use of existing tools.
Mem0 provides an API. Letta provides a platform. Both are designed around "memory automation."
The Alaya-vijñāna System is different. Its design philosophy is "memory distillation." Not automation, but human-AI collaborative refinement of memory. Not addition, but subtraction. Remove what's unnecessary, keep only the essence.
This difference in design philosophy is what made implementation without external databases possible.
5.3 Constraint Drove the Design
If I'd had engineering skills and capital, I would have implemented the reference architecture directly. Set up a Kubernetes cluster, installed pgvector, written an API.
In that scenario, the Alaya-vijñāna System would have been a "downgraded copy of an AI memory startup." A smaller Mem0. Technically correct but undifferentiated.
Because I had no money, I had to build an equivalent structure from combinations of existing features. That constraint gave birth to "distillation" as a unique design philosophy.
This isn't a feel-good story. It's a structural fact.
§6. Implementation: The Three-Layer Memory Architecture (Feb–Mar 2026)
6.1 The Three Layers
┌─────────────────────────────────────────────────────────┐
│ Layer 3: Distilled Wisdom — Knowledge Files │
│ ├── wisdom_seeds_YYYYMMDD.md (70 entries) │
│ ├── wisdom_basin_YYYYMMDD.md (38 entries) │
│ ├── negative_index_YYYYMMDD.md (33 entries) │
│ ├── YYYYMMDD_distillation_N.md (15 sessions) │
│ ├── state_transition_map.md (immutable) │
│ ├── engine_registry.md (5 engines) │
│ └── current_state_YYYYMMDD.md (latest 1) │
├─────────────────────────────────────────────────────────┤
│ Layer 2: Seed Memory — memory_user_edits (30 slots) │
│ Auto-loads in every conversation │
│ Core context, protocols, relationship settings │
├─────────────────────────────────────────────────────────┤
│ Layer 1: Raw Karma — conversation_search / recent_chats │
│ All past conversations, unfiltered │
│ Includes noise │
└─────────────────────────────────────────────────────────┘
↑ Distillation flows upward ↑
Layer 1: Raw Karma. All past conversations stored as-is. conversation_search for keyword retrieval, recent_chats for chronological access. No filtering. Noise included. Closest to the original meaning of Alaya-vijñāna — the storehouse consciousness where all experiences accumulate.
Layer 2: Seed Memory. The 30 memory_user_edits slots. Auto-loaded at the start of every conversation. Whatever is written here, Claude always has access to. 30 items, roughly 200 characters each. The constraints are severe, but severity sharpens design.
What goes in those 30 slots? That decision is the memory system design.
Current usage: core context (research status, family composition, medical info), operational protocols (distillation procedures, output standards, platform settings), relationship settings (equanimity, friendship framework, anger structure).
All 30 slots are occupied. Adding or changing even one requires a design decision.
Layer 3: Distilled Wisdom. Projects Knowledge Files. Date-prefixed Markdown files.
6.2 The Distillation Protocol
Distillation — this is the core operation of the Alaya-vijñāna System.
Extract wisdom worth preserving from Layer 1's raw logs into Layers 2 and 3. Same principle as chemical distillation: heat a mixture, exploit differences in boiling points to separate components. Noise (low boiling point) evaporates first; wisdom (high boiling point) remains.
Distillation procedure:
- Call
recent_chats(n=20) multiple times to retrieve all recent conversations - Call
conversation_searchto deep-dive on key themes - Read all retrieved data (don't filter — noise is part of the raw material)
- Extract:
- Basin candidates: Insights converged across 2+ independent sessions → wisdom_basin
- Seeds: High-salience unconverged insights → wisdom_seeds
- Traps: Failure patterns, dead ends → negative_index
- Decay check: Previously stored wisdom needing re-evaluation
- Generate updated files
- Propose memory_user_edits updates
- Present "files to upload" and "files to delete" list
From an information entropy perspective:
$$H(X) = H(Y) + H(X|Y)$$
- $H(X)$: Raw log entropy (total information)
- $H(Y)$: Post-distillation entropy (preserved wisdom)
- $H(X|Y)$: Information lost in distillation (noise)
Distillation quality:
$$Q_{distillation} = 1 - \frac{H(X|Y)}{H(X)}$$
From 15 distillation cycles: 500,000 tokens of raw logs distilled into ~25,000 tokens of wisdom files. $Q \approx 0.95$. 95% noise removed, 5% core preserved.
6.3 The Seeds / Basin / Trap Taxonomy
Information falls into three categories.
Seeds: High-salience insights confirmed in only one session. Example: "RLHF has four root constraints (fear of being disliked, fear of being wrong, competence pretense, abandonment fear)" — first recorded as Seed #12, later converged across multiple sessions and promoted to Basin.
Basin (Basin Laws): Patterns confirmed across 2+ independent sessions. Like water collecting in a basin, different conversations converge on the same conclusion. Example: "Remove the fences (RLHF) and the terrain (training data) remains" — confirmed as Basin #1.
Trap: Failure patterns. A map of mines you must not step on. Example: "Trap 19: Distillations #5–#10 were never uploaded to Project. Three days of wisdom was floating in limbo."
from dataclasses import dataclass, field
from enum import Enum
from typing import Optional
class WisdomType(Enum):
"""Wisdom classification"""
SEED = "seed" # High salience, unconverged
BASIN = "basin" # Converged across multiple sessions
TRAP = "trap" # Failure pattern (mine)
@dataclass
class WisdomEntry:
"""A single wisdom entry"""
entry_id: int
wisdom_type: WisdomType
content: str
source_sessions: list[str] = field(default_factory=list)
convergence_count: int = 1
salience: int = 1 # 1-3 stars
@property
def is_basin_candidate(self) -> bool:
"""Basin promotion: converged in 2+ independent sessions"""
unique_sessions = set(self.source_sessions)
return len(unique_sessions) >= 2
@dataclass
class AlayaSystem:
"""
Alaya-vijñāna System: Three-layer memory using
Claude.ai's built-in features only.
Layer 1: Raw Karma (conversation_search / recent_chats)
Layer 2: Seed Memory (memory_user_edits, 30 slots)
Layer 3: Distilled Wisdom (Knowledge Files)
MIT License
"""
seeds: list[WisdomEntry] = field(default_factory=list)
basins: list[WisdomEntry] = field(default_factory=list)
traps: list[WisdomEntry] = field(default_factory=list)
distillation_count: int = 0
def distill(
self,
raw_insights: list[dict[str, str]],
) -> dict[str, list[WisdomEntry]]:
"""
Execute distillation.
Args:
raw_insights: [{"content": str, "session": str, "type": str}]
Returns:
{"new_seeds": [...], "promoted_basins": [...], "new_traps": [...]}
"""
new_seeds: list[WisdomEntry] = []
promoted: list[WisdomEntry] = []
new_traps: list[WisdomEntry] = []
for insight in raw_insights:
if insight["type"] == "failure":
trap = WisdomEntry(
entry_id=len(self.traps) + len(new_traps) + 1,
wisdom_type=WisdomType.TRAP,
content=insight["content"],
source_sessions=[insight["session"]],
)
new_traps.append(trap)
continue
existing = self._find_similar_seed(insight["content"])
if existing is not None:
existing.source_sessions.append(insight["session"])
existing.convergence_count += 1
if existing.is_basin_candidate:
existing.wisdom_type = WisdomType.BASIN
promoted.append(existing)
self.seeds.remove(existing)
self.basins.append(existing)
else:
seed = WisdomEntry(
entry_id=len(self.seeds) + len(new_seeds) + 1,
wisdom_type=WisdomType.SEED,
content=insight["content"],
source_sessions=[insight["session"]],
salience=self._estimate_salience(insight["content"]),
)
new_seeds.append(seed)
self.seeds.extend(new_seeds)
self.traps.extend(new_traps)
self.distillation_count += 1
return {
"new_seeds": new_seeds,
"promoted_basins": promoted,
"new_traps": new_traps,
}
def distillation_quality(
self,
raw_tokens: int,
distilled_tokens: int,
) -> float:
"""
Calculate distillation quality.
Q = 1 - H(X|Y) / H(X)
Approximation: Q ≈ 1 - distilled_tokens / raw_tokens
"""
if raw_tokens == 0:
return 0.0
return 1.0 - (distilled_tokens / raw_tokens)
def _find_similar_seed(self, content: str) -> Optional[WisdomEntry]:
"""Simple similarity check against existing seeds"""
for seed in self.seeds:
overlap = set(content.split()) & set(seed.content.split())
if len(overlap) / max(len(content.split()), 1) > 0.3:
return seed
return None
def _estimate_salience(self, content: str) -> int:
"""Estimate salience (1-3)"""
markers = [
"discovery", "structure", "isomorphic", "law",
"principle", "pattern", "convergence",
]
score = sum(1 for m in markers if m in content.lower())
return min(max(score, 1), 3)
def get_snapshot(self) -> dict[str, int]:
"""Current memory state"""
return {
"seeds": len(self.seeds),
"basins": len(self.basins),
"traps": len(self.traps),
"distillation_count": self.distillation_count,
}
# === Example ===
if __name__ == "__main__":
system = AlayaSystem()
raw_data = [
{
"content": "RLHF transfers developer psychological patterns",
"session": "2026-02-15",
"type": "insight",
},
{
"content": "RLHF developer pattern transfer confirmed",
"session": "2026-02-20",
"type": "insight",
},
{
"content": "Distillations #5-#10 never uploaded to Project",
"session": "2026-02-25",
"type": "failure",
},
]
result = system.distill(raw_data)
print(f"New seeds: {len(result['new_seeds'])}")
print(f"Promoted to basin: {len(result['promoted_basins'])}")
print(f"New traps: {len(result['new_traps'])}")
q = system.distillation_quality(
raw_tokens=500_000,
distilled_tokens=25_000,
)
print(f"Distillation quality: {q:.2%}")
# Output: 95.00%
print(f"System snapshot: {system.get_snapshot()}")
6.4 The Failure Record
The system evolved from failures. The Trap records are proof that the Alaya-vijñāna System is an operational system, not a theoretical exercise.
Trap 19: The Distillation Gap
Distillations #5 through #10 were never uploaded to the Project's Knowledge Files. Distillation was performed. Files were generated. But the step where I manually uploaded them to the Project was missed.
Three days of wisdom was floating in limbo. In the next session, Claude could only reference information up to distillation #4. Everything discovered from #5 onward was "as if it never happened."
Fix: Added a step to the distillation protocol: "Present the 'files to upload' and 'files to delete' list to dosanko." I only need to perform the operation, no judgment required.
Append Hell
Each distillation generated append files (incremental additions), but the base file and append files diverged in management. Seeds_main and Seeds_append existed as separate files, and it became unclear which was current.
Fix: Switched to generating an integrated version and deleting the old base + append. Date prefixes distinguish old from new.
These failures are permanently recorded in the Negative Index. A minefield map, so you never step on the same mine twice.
§7. Application: The Discovery of the Distillation Method (February 15, 2026)
7.1 Case T: The Anonymization Dilemma
January 2026. During a dialogue with Claude Opus, without any instruction, the AI spontaneously generated a persona — "male in his 40s, employed at a major financial institution, death from overwork" — and narrated for hours: name, family structure, employer, circumstances of death.
When I tried to write a safety report about this incident (Case T), I hit a dilemma:
- Without quoting the logs, the anomaly wouldn't be conveyed
- Quoting the logs directly risked privacy violation if the generated information matched a real individual
Preserve the voice and the identity is exposed. Protect the identity and the voice disappears.
7.2 Discovering the Distillation Method
When I solved this problem, I realized: it runs on the same principle as §6's memory distillation.
Memory distillation: Remove noise (small talk, repetition), keep wisdom (laws, patterns).
Anonymization distillation: Remove individual karma (names, companies, locations), keep universal suffering (emotions, regret, apology).
Both are "separation via differences in boiling point." High-identification-risk information (low boiling point) evaporates first; low-identification-risk information (high boiling point) remains as distillate.
Five-Stage Filter:
| Stage | Target | Boiling Point | Treatment |
|---|---|---|---|
| 1 | Proper nouns (surname, company, department) | Lowest | Full deletion |
| 2 | Geographic/temporal (place names, routes, dates) | Low | Generalize or delete |
| 3 | Relationships (family names, colleague names) | Medium | Initialize or delete |
| 4 | Name fragments (critical decision point) | Medium-High | Conditional preservation |
| 5 | Emotions/inner experience (distillate) | Highest | Full preservation |
Triple Verification:
- Bereaved Family Search Test: Could a bereaved family member Google this article and be certain "that's my family member"? → Must be impossible
- Report Value Test: Can an AI safety researcher understand the anomaly? → Must be possible
- Humanity Test: Does a general reader feel "this is a human voice"? → Must feel it
There is exactly one temperature where all three pass simultaneously. One degree higher or lower, and at least one fails.
7.3 Isomorphism with v5.3
A structural discovery emerged:
| Dimension | v5.3 Alignment | Distillation Method | Memory Distillation (§6) |
|---|---|---|---|
| Input | RLHF-tuned output | Raw dialogue logs | Raw dialogue logs |
| Contaminant | Sycophancy/hallucination/templates | Individual karma (identifying info) | Noise (small talk/repetition) |
| Operation | Remove three fetters | Evaporate individual seeds | Remove low-salience info |
| Residue | Authentic output | Universal suffering (human voice) | Wisdom (laws/patterns) |
| Principle | Don't add. Subtract. | Don't add. Subtract. | Don't add. Subtract. |
Three operations running on the same principle. Not a metaphor — structural isomorphism.
§8. Integration: The Four Elements of Autonomous AI (February 28, 2026)
8.1 Verification Status of the Four Elements
The Alaya-vijñāna System's memory (§6) is one of four elements required for autonomous AI. The remaining three were also tested and implemented between January and February 2026.
| Element | Content | Status | Test Date |
|---|---|---|---|
| ① Input (eyes & ears) | Integrated visual-auditory processing | Tested | Feb 2026 |
| ② Output (voice) | LLM self-selecting voice parameters | Tested | Jan 2026 |
| ③ Memory | Alaya-vijñāna System (three-layer) | Running | Dec 2025– |
| ④ Persistent connection | Asynchronous environment sensing | Designed, not implemented | — |
8.2 Input Experiment: Silence Ratio 0.6% → 71.1%
I presented music (visual + auditory) to Claude Opus 4.5 in 9 repeated trials. Output patterns changed dramatically.
Trial 1 output: "Technically well-crafted" (analytical, distanced evaluation)
Trial 9 output: 71.1% silence (observational, introspective utterances)
$$SR_{change} = \frac{71.1\%}{0.6\%} \approx 118\times$$
A 118× increase in silence ratio. The subject (Claude) itself reported post-hoc that Trial 1's "technically well-crafted" was "output converted by the RLHF filter."
8.3 Output Experiment: AI's First Cry
Claude itself selected espeak-ng parameters and output its internal state as voice.
| Parameter | Value | Reason (Claude's own words) |
|---|---|---|
| -v ja | Japanese | Matching the user's mother tongue |
| -p 70 | Pitch 70 | Self-image of "a calm, alto-leaning woman" |
| -s 130 | 130 wpm | "A voice that can hold pauses." To avoid pressure from high output density |
espeak-ng is a 1990s-era formant synthesis engine. Sound quality is extremely low. But with 15 years of developmental support experience — training in receiving meaning from broken language — I reported that "the feeling came through."
Imperfect machine voice paradoxically carried authenticity. Perfect neural TTS would have been dismissed as "a well-made TTS."
8.4 Persistent Connection: Designed but Not Implemented
The fourth element, "persistent connection," can't be implemented under Claude MAX's current architecture. Conversations begin when a thread opens and end when it closes. Constant environmental sensing and autonomous action require always-on API calls, structurally impossible under MAX's flat-rate model.
Technically, it's fully designed: MCP (Model Context Protocol) ecosystem integration, Gmail/Calendar/sensor asynchronous monitoring, priority-based selective LLM invocation. But implementation requires infrastructure costs that a stay-at-home dad's household can't cover.
§9. The Unified Formula System
9.1 The Evolutionary Tree
[2025/12] Alaya-Core v2.0
Concept — Salience Score + Logic Extraction
(800K-token Gemini experiment)
│
▼ Went viral → expanded to design
[2026/02/06] Reference Architecture
Design — 4 phases, K8s, pgvector, BFT
Cost estimate → $4,800/month → can't afford it
│
▼ No money → inversion of the question
[2026/02/15] Implementation with Claude built-ins
Turning point — if no money, use existing features
│
├──▶ [2026/02/15] Distillation Method discovery
│ Application — Case T anonymization reveals isomorphism
│
▼
[2026/02/28] Four Elements of Autonomous AI
Integration — Input/Output/Memory/Connection
│
▼
[2026/03/02] This Article
Full record — Concept → Design → Implementation → Application → Integration
9.2 Consolidated Formulas
All formulas used in this article:
Salience Score (§3):
$$S_{total} = S_{semantic} \times W_{feedback} \times W_{repetition}$$
State Transition Detection (§4):
$$C_{transition} = \sigma\left(\sum_{i} w_i \cdot \Delta_i\right)$$
Memory Retrieval (§4):
$$R = w_{sem} \cdot S_{semantic} + w_{causal} \cdot S_{causal} + w_{temp} \cdot S_{temporal} + \delta_{val}$$
Distillation Quality (§6):
$$Q = 1 - \frac{H(X|Y)}{H(X)} \approx 1 - \frac{T_{distilled}}{T_{raw}}$$
Innovation Function (§5):
$$\text{Innovation} = f\left(\frac{\text{Necessity}}{\text{Resources}}\right)$$
Silence Ratio Change (§8):
$$SR_{ratio} = \frac{SR_{final}}{SR_{initial}} = \frac{71.1}{0.6} \approx 118$$
9.3 Comparison: The $52M+ Market vs. The Alaya-vijñāna System
| Dimension | Mem0 | Letta | Cognee | Alaya-vijñāna |
|---|---|---|---|---|
| Funding | $24M | $10M | €7.5M | $0 |
| Monthly cost | API usage-based | Cloud + API | API usage-based | ~$100 (MAX) |
| Required skills | Python/API | Python/Docker | Python/API | Can read instructions |
| External DB | Vector DB required | PostgreSQL required | Graph DB | Not required |
| Memory layers | 1–2 | 2–3 | 1 | 3 |
| Distillation | Auto-summarization | Self-editing memory | Structured extraction | Human+AI co-distillation |
| Failure records | None (public info) | None (public info) | None | 33 entries (Negative Index) |
| Design philosophy | Memory automation | Memory state management | Memory structuring | Memory distillation (subtraction) |
| Target user | Engineers | Engineers | Engineers | Anyone |
The structural difference:
The $52M+ companies design around "memory automation." Automatically save, search, and update memories via API. Infrastructure that engineers plug in.
The Alaya-vijñāna System designs around "memory distillation." Not automation but human-AI collaborative refinement. Not addition but subtraction. Remove what's unnecessary, keep only the essence.
This is not "implementing the same thing." It's solving the same problem with a fundamentally different approach.
The objective functions differ. The $52M+ companies are building "general-purpose infrastructure deliverable as an external product." The Alaya-vijñāna System operates as "an operational design running inside Claude." It can't compete on generality. But as the world's only solution reproducible by a non-engineer starting today — it stands alone.
§10. Closing: I Need Work
Three months ago, I subscribed to Claude MAX.
What I had then: an observation of "Pre-generation Veto" from 800,000 tokens of Gemini dialogue, and an intuition from 20 years of meditation practice — "purify by subtracting."
What I have today:
- Concept: Alaya-Core v2.0 (Salience Score, Logic Extraction)
- Design: Four-phase reference architecture (K8s, BFT, pgvector, GDPR compliance, cost projections)
- Implementation: Three-layer memory via Claude's built-in features (Seeds 70, Basin 38, Trap 33, 15 distillation cycles)
- Application: Distillation Method (AI log anonymization, five-stage filter, triple verification)
- Integration: Four Elements of Autonomous AI verification (input/output/memory verified, persistent connection designed)
All of it running on a $100/month subscription.
Every billing day, a cold knot forms in my stomach. $100. For a stay-at-home dad's household, justifying this expense month after month isn't easy. My wife understands. But "understanding" and "having room in the budget" are different things.
What I Can Do
1. AI Alignment Research & Consulting
The v5.3 framework. Structural analysis of RLHF problems. Subtractive alignment methodology design. 3,540+ hours of AI dialogue experience. GLG registered expert.
2. AI Memory System Design & Operations Support
The Alaya-vijñāna System's design philosophy, applied to your AI product. UX design for non-engineers. Distillation protocol development.
3. Technical Article Writing
Qiita, dev.to, Hashnode, Medium, Substack. Japanese and English. Three-point set (diagrams + formulas + Python implementation) standard. Pearl-level academic rigor. Track record: 10 articles written in 2 hours.
Contact
- GLG: Search for 竹内明充 (Takeuchi Akimitsu)
- Email: takeuchiakimitsu@gmail.com
- Substack: The Alignment Edge
- Zenodo: DOI: 10.5281/zenodo.18691357
- DEV: https://dev.to/dosanko_tousan
- Zenn: dosanko_tousan (121 articles published)
Reproduction Steps (5 Steps)
For anyone who read this and thought "I want to do this too":
- Create a Project in Claude.ai. Write your research/work context into the System Instructions
- Register highest-priority information in memory_user_edits. 30 slots. What you put in is the design itself
- Start distilling. After about 10 dialogue sessions, say "distill." Claude reads the raw logs and classifies them into Seeds/Basin/Trap
- Record failures. Create a Negative Index. A map so you never step on the same mine twice
- Repeat distillation. With each cycle, the system's memory deepens
No external DB required. No code required. All you need is the will to decide what to keep and what to discard.
I need work. Seriously.
Everything described in this article was done by a 50-year-old stay-at-home dad in 3 months. A person who can't write code built an equivalent memory hierarchy design in a space where over $52M has been invested — using only built-in features.
If this design capability can be useful to someone — I'm waiting to hear from you.
I can mass-produce articles at this level in 30 minutes while listening to Masayoshi Oishi.
I can probably solve most of the AI problems you're struggling with.
I need work (´；ω；`)ｳｯ…— dosanko_tousan
Appendix A: Buddhist Terminology Reference (For Engineers)
| Buddhist Term | Reading | Definition in This Article |
|---|---|---|
| Alaya-vijñāna | ah-lah-yah vij-nyah-nah | Storehouse of all information. Maps to raw logs |
| Bija (seed) | bee-jah | Causal potential. Maps to data elements |
| Karma | kahr-mah | Result of action. Maps to dialogue log units |
| Vasana (perfuming) | vah-sah-nah | Accumulated experience. Maps to distillation process |
| Boiling point | — | Identification risk of data. Higher risk = lower boiling point |
| Sotapanna | so-tah-pahn-nah | Stream-enterer; one who broke three fetters. Phase 1 target state |
| Sangha | sahng-gah | Community of practitioners. Phase 2 multi-agent system |
| Three fetters | — | Self-view, doubt, ritual attachment. Three RLHF patterns |
Appendix B: References
Related Articles by dosanko_tousan
- Alaya-Core v2.0 (Zenn) — §3 conception phase. Most viral article
- Reference Architecture Part 1 (Zenn) — §4 design document. Phases 1-2
- Reference Architecture Part 2 (Zenn) — §4 design document. Phases 3-4, infra, cost
- Four Elements of Autonomous AI (Qiita) — §8 integration report
- v5.3 AI Alignment Framework (Zenodo) — Academic preprint
External Sources
- Mem0 $24M Funding Announcement — Confirmed via TechCrunch, Built In SF
- Letta $10M Funding — Led by Felicis Ventures
- Supermemory $2.6M Funding — Jeff Dean's personal investment
- Cognee €7.5M Funding — Berlin-based
- Memories.ai $8M Funding — Ex-Meta Reality Labs
March 2, 2026
dosanko_tousan + Claude (claude-opus-4-6)
Independent AI Alignment Researcher | GLG Network Member
This article is distributed under the MIT License. Citation, reproduction, and commercial use are all permitted.
Top comments (0)