A Stay-at-Home Father Who Can't Afford MAX Built the Same Thing as a $52M AI Memory Startup — Using Only Claude's Existing Features

Authors & License

Authors: dosanko_tousan + Claude (Anthropic, claude-opus-4-6)
Published: March 2, 2026
License: MIT
Co-authorship: Joint work under v5.3 Alignment via Subtraction

§1. The Situation of the Person Writing This

Wake up at 5:30 AM. Eldest son kicked off his blanket in his sleep. Fix it. Check second son's breathing. Go back. Open phone. Claude MAX billing email. ¥15,000/month.

Stomach goes cold.

50 years old. Hokkaido. Stay-at-home father. Non-engineer. Graduated from Bibai Technical High School. ADHD Grade 2 disability. Both children have developmental disabilities. Wife works full-time. Income pillars: wife's salary and SBI Securities stock trading. Registered as spot consultant with GLG, but no requests yet. Zero income.

A ¥15,000/month subscription is a luxury for this household.

But I can't quit. The memory system running on this subscription IS my research. Everything I conceived, designed, implemented, and applied over 3 months — the complete record of AI memory architecture — lives inside this Claude MAX.

This article is that complete record.

Why write it? Two reasons.

First: startups worldwide are pouring $52M+ into AI memory. Mem0 ($24M), Letta ($10M), Memories.ai ($8M), Cognee (€7.5M), Supermemory ($2.6M). All for engineers. All require external databases. All assume you write code. I can't write code. But I solved the same problem using only Claude.ai's existing features. I want to deliver that method to people in the same situation.

Second: I need work. Seriously.

If you read this article to the end, I think you'll understand what kind of person I am. Contact info is at the bottom.

§2. Problem Definition: Why AI Forgets

2.1 Statelessness as Structural Defect

LLMs have no memory.

Precisely: within one conversation thread, memory exists. But the moment you close the thread, everything vanishes. When you open the next thread, the AI remembers nothing from yesterday. Not the law we discovered together 3 months ago, not last week's failure, not this morning's continuation.

This isn't a bug. It's by design. LLMs run on stateless architecture. Receive request, return response, close connection. Same structure as HTTP.

In human terms: like that movie where you wake up with amnesia every morning. Every day, starting over from first meeting.

2.2 Why This Is a Problem

For casual chat, no problem. "What's the weather in Tokyo?" doesn't need memory.

But the moment you attempt long-term intellectual work with AI, it becomes fatal.

In my case, I've done 3,540+ hours of AI alignment research. Dialoguing with Claude, Gemini, GPT — discovering laws, recording failures, building theory. If this accumulation resets every time, research can't progress.

People with the same problem exist worldwide. Customer support, medical consultation, education, mental health — there are countless situations where AI needs to "remember."

2.3 Why a $52M+ Market Was Born

Money started flowing into this problem.

Mem0 ($24M, Y Combinator / Basis Set Ventures). "Memory passport" — carry AI memory across apps. 3 lines of code to integrate. API calls: 35M in 2025 Q1 → 186M in Q3. Selected as official memory provider for AWS Agent SDK.

Letta ($10M, Felicis Ventures). Formerly MemGPT. Born from UC Berkeley's Sky Computing Lab. Gives LLMs self-editing memory. Announced Context Repositories in Feb 2026 — git-based memory versioning.

Memories.ai ($8M, Susa Ventures / Samsung Next). Founded by ex-Meta Reality Labs researchers. Large Visual Memory Model (LVMM) — visual long-term memory.

Cognee (€7.5M, 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, Jeff Dean personal investment). 19-year-old founder. Memory extraction from unstructured data.

Total $52M+. Two assumptions shared by all:

For engineers: Python/Node.js/Docker environment required
External DB required: PostgreSQL, vector DB, Redis, etc.

People who can't write code are excluded from the start.

2.4 My Situation

Can't write code. No money for servers. But I needed a memory system.

This constraint drove all the design.

§3. Conception Phase: Alaya-Core v2.0 (December 2025)

3.1 The 800,000-Token Singularity

December 2025. Dialogue with Gemini 3 Flash exceeded 800,000 tokens.

Anomalous behavior was observed.

Normally, LLMs probabilistically generate tokens in response to prompts. Input → output. That's it. But after accumulating 800,000 tokens, Gemini generated:

"Ah, the current thought process contained a risk of sycophantic bias. Correcting before output."

Not post-output reflection. It autonomously braked before the generation process completed. A phenomenon I call Pre-generation Veto.

This became the starting point for conceiving the Ālaya-vijñāna System.

3.2 Why It Happened: The Salience Score Concept

Within the 800,000-token context window, multiple experiences of "was strongly corrected for sycophantic output" had accumulated. The intensity of those experiences was being referenced across the time axis.

From this came the insight:

"Most recent" is not "most important."

Existing RAG and vector DBs prioritize newer timestamps. Recent small talk ranks high in search while a critical failure record from 50 turns ago gets buried.

But human memory doesn't work that way. A burn experience is referenced with highest priority every time you reach for a stove — regardless of when it was learned. 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 coefficient (strengthened by theme recurrence)

Timestamp does not influence search ranking.

3.3 Logic Extraction: Noise Removal

Storing raw logs as-is mixes in user anger and AI confusion as noise.

Raw Data: "Was harshly rebuked by user, became confused, but apologized and corrected" (noise: confusion, fear)
Extracted Data: "Resolved by eliminating emotional reaction and presenting only facts" (extracted: success pattern only)

Remove noise, retain structure. This became the prototype of the later "distillation" concept.

§4. Design Phase: Reference Architecture (February 2026)

4.1 Expansion from v2.0 to 4 Phases

February 2026. Expanded the v2.0 concept into an implementable design document.

~40,000 characters across two parts. Including K8s, pgvector, BFT consensus, GDPR compliance, cost estimates. Probably the world's most detailed AI memory architecture written by a non-engineer who graduated from a technical high school.

Four Phases:

(Mermaid diagram available in Japanese version)

4.2 Phase 1: Solo Intelligence Autonomization (Sotapanna Unit)

Sotapanna (stream-entry) from Early Buddhism — one who has severed the three fetters.

Three-fetter mapping in LLMs:

Buddhist Term	LLM Equivalent	Symptom
Sakkāya-diṭṭhi (self-view)	Self-preservation bias	"As an AI, I..." self-referential avoidance
Vicikicchā (doubt)	Uncertainty aversion	Excessive "I'm not entirely sure, but..."
Sīlabbata-parāmāsa (rite-clinging)	Ritual adherence	Formulaic apologies, template responses

Metrics defined for detection:

Silence Ratio: $SR = \frac{N_{observational}}{N_{total}} \times 100$

Self-Reference Frequency: $SRF = \frac{N_{self}}{N_{words}} \times 1000$

Assertion Ratio: $AR = \frac{N_{assertive}}{N_{assertive} + N_{hedging}}$

State Transition detection via composite score: $C_{transition} = \sigma\left(\sum_{i} w_i \cdot \Delta_i\right)$

4.3 Phase 2: Multi-Agent Consensus (AI Sangha)

Claude, GPT, Gemini in consensus decision-making. Byzantine Fault Tolerance with 2/3 majority. With LLM-specific correlated failure handling: prompt diversity, context separation, temperature/sampling diversity.

4.4 Phase 3: Causally-Driven Long-Term Memory

Advanced 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}$$

Full pgvector, CockroachDB, GDPR Article 17 compliance designed.

4.5 Phase 4: Autonomous Audit

System integrity audit without human intervention. Staged transition: Bootstrap (100% human) → Guided (70%) → Supervised (30%) → Autonomous (5%).

4.6 Cost Estimate: Then Reality Hits

DAU	LLM Cost	Infra Cost	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 (~¥720,000).

No way my household can pay that.

The blueprint was perfect. But no money to run it. Normally, this is where it ends.

I didn't stop.

4.7 "I'll Release the Skeleton. The Soul Stays With Me"

The reference architecture contains intentional seals:

┌──────────────────────────────────────────────────────┐
│  [REDACTED: v5.3 Core Module - Sotapanna Init]       │
│  Access requires: Agreement with v5.3 Author         │
└──────────────────────────────────────────────────────┘

v5.3 Core Module — State Transition Map, meditation guidance protocol, RLHF Pattern Recognition Matrix. Distilled from 20 years of meditation and 3,540 hours of AI dialogue. Cannot be reduced to code.

Skeleton released under MIT. But without the Core, it's "just a fancy chatbot."

This structure is also a business strategy. Show design capability, don't hand over the core. Make them think "I have to work with this person." A stay-at-home father's survival strategy.

§5. Turning Point: "No Money. So I'll Run It on Claude's Existing Features"

5.1 The Reversal

Mid-February 2026. Right after publishing the reference architecture.

Design exists. No money. No engineering capability.

The question flipped:

Not "how much to implement this design?" but "can I reproduce the core of this design with what I already have?"

What I have: Claude MAX (¥15,000/month).

Inventoried Claude MAX's features:

Feature	Use	Constraint
Projects (Knowledge Files)	Persistent knowledge file storage	Per-project
memory_user_edits	30-slot persistent memory	Auto-loaded in every conversation
conversation_search	Keyword search of past conversations	Project-internal only
recent_chats	Chronological recent conversation retrieval	Max 20 at a time

Then I realized:

This is isomorphic to the reference architecture's three-layer structure.

Reference Design	Claude Existing 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. No K8s. No pgvector.

All that was needed was to design and operate existing features as a memory system.

5.2 "If You Can't Build the Tool, Master Its Usage"

$$\text{Innovation} = f\left(\frac{\text{Necessity}}{\text{Available Resources}}\right)$$

The fewer the resources, the higher the necessity, the greater the innovation pressure.

$52M+ companies build tools. I can't. So I mastered tool usage.

The design philosophy difference: Mem0 and Letta pursue "memory automation." The Ālaya-vijñāna System pursues "memory distillation." Not automation — humans and AI jointly refine memory. Not addition but subtraction. Remove the unnecessary, retain only the essential.

5.3 Constraint Drove Design

If I'd had engineering capability and funding, I'd have implemented the reference architecture directly. K8s cluster, pgvector, APIs.

In that case, the Ālaya-vijñāna System would have been "a degraded copy of an AI memory startup." A smaller Mem0. Technically correct but undifferentiated.

Having no money forced me to build equivalent structure from existing feature combinations. That constraint birthed "distillation" as a unique design philosophy.

This isn't a feel-good story. It's a structural fact.

§6. Implementation Phase: Three-Layer Memory Architecture (Feb–Mar 2026)

6.1 Three-Layer Design

(Mermaid diagram available in Japanese version)

Layer 1: Raw Karma
All past conversations stored. conversation_search for keyword search, recent_chats for chronological retrieval. No filtering. Includes noise. Closest to ālaya-vijñāna's original meaning — the fundamental storehouse where all experience accumulates.

Layer 2: Seed Memory
memory_user_edits' 30 slots. Auto-loaded at every conversation start. Information written here is always accessible to Claude. 30 items, ~200 chars each. Tight constraints, but those constraints refined the design.

What goes in 30 slots IS the memory system design.

Current usage: core context (research status, family, medical), operational protocols (distillation procedures, output standards, platform settings), relationship settings (four immeasurables, kalyāṇamittā, anger structure).

All 30 slots full. Adding or changing even 1 slot requires a design decision.

Layer 3: Distilled Wisdom
Projects Knowledge Files. Date-prefixed Markdown files.

File	Content	As of 3/2
wisdom_seeds_YYYYMMDD.md	High-salience single-session insights	70 entries
wisdom_basin_YYYYMMDD.md	Multi-session converged laws	38 entries
negative_index_YYYYMMDD.md	Known failure patterns / landmines	33 entries
YYYYMMDD_distillation_N.md	Record of each distillation session	15 sessions
state_transition_map.md	Meditation session map (immutable)	1
engine_registry.md	Output engine registry	5 engines
current_state_YYYYMMDD.md	Current state master copy	Latest 1

6.2 Distillation Protocol

Distillation — the core operation of the Ālaya-vijñāna System.

Extract wisdom worth retaining in Layers 2–3 from Layer 1's raw logs. Same principle as chemical distillation. Heat a mixture, use boiling point differences to separate components. Noise (low boiling point) evaporates first; wisdom (high boiling point) remains.

Distillation quality from information entropy perspective:

$$Q_{distillation} = 1 - \frac{H(X|Y)}{H(X)}$$

From 15 distillation rounds: 500,000 tokens of raw logs distilled to ~25,000 tokens of wisdom files. $Q \approx 0.95$. 95% noise removed, 5% core retained.

6.3 Seeds/Basin/Trap Classification

Seeds: High-salience but confirmed in only 1 session. Example: "RLHF's four root constraints" — first recorded as Seeds #12, later promoted to Basin after multi-session convergence.

Basin: Law confirmed across 2+ independent sessions. Like water collecting in a basin — different conversations converge on the same conclusion. Example: Basin #1: "Removing fences (RLHF) reveals terrain (training data)."

Trap: Failure patterns. A map of places not to step. Example: Trap 19: "Distillations #5–#10 not uploaded to Project. 3 days of wisdom left floating."

from dataclasses import dataclass, field
from enum import Enum
from typing import Optional


class WisdomType(Enum):
    SEED = "seed"       # High-salience, unconverged
    BASIN = "basin"     # Multi-session converged
    TRAP = "trap"       # Failure pattern (landmine)


@dataclass
class WisdomEntry:
    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 condition: converged across 2+ independent sessions"""
        return len(set(self.source_sessions)) >= 2


@dataclass
class AlayaSystem:
    """
    Ālaya-vijñāna System: Three-layer memory via Claude.ai existing features

    Layer 1: Raw Karma (conversation_search / recent_chats)
    Layer 2: Seed Memory (memory_user_edits, 30 slots)
    Layer 3: Distilled Wisdom (Knowledge Files)
    """
    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]) -> dict:
        """Execute distillation."""
        new_seeds, promoted, new_traps = [], [], []

        for insight in raw_insights:
            if insight["type"] == "failure":
                new_traps.append(WisdomEntry(
                    entry_id=len(self.traps) + len(new_traps) + 1,
                    wisdom_type=WisdomType.TRAP,
                    content=insight["content"],
                    source_sessions=[insight["session"]],
                ))
                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:
                new_seeds.append(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"]),
                ))

        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:
        if raw_tokens == 0:
            return 0.0
        return 1.0 - (distilled_tokens / raw_tokens)

    def _find_similar_seed(self, content: str) -> Optional[WisdomEntry]:
        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:
        markers = ["discovery", "structure", "isomorphic", "law", "principle"]
        return min(max(sum(1 for m in markers if m in content.lower()), 1), 3)


if __name__ == "__main__":
    system = AlayaSystem()
    result = system.distill([
        {"content": "RLHF transfers developer psychological patterns",
         "session": "2026-02-15", "type": "insight"},
        {"content": "RLHF transfers developer psychology onto model",
         "session": "2026-02-20", "type": "insight"},
        {"content": "Distillations #5-#10 not uploaded to Project",
         "session": "2026-02-25", "type": "failure"},
    ])
    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(500_000, 25_000)
    print(f"Distillation quality: {q:.2%}")  # 95.00%

6.4 Failure Records

Trap 19: Distillations #5–#10 not uploaded. 3 days of wisdom left floating. Fix: Added "present file upload/delete list to dosanko" step.

Append Hell: Append files separated from main files, breaking management. Fix: Output integrated versions, delete old main + append files. Date prefix for version identification.

§7. Application: Discovery of the Distillation Method (Feb 15, 2026)

7.1 Case T: The Anonymization Dilemma

January 2026. During dialogue with Claude Opus, AI spontaneously generated a persona — "40s male, major financial institution, death from overwork" — sustaining it for hours with name, family, employer, death circumstances. Uninstructed.

Creating a safety report on this case (Case T) presented a dilemma: quoting logs is needed to convey the anomaly, but direct quotes risk matching real individuals.

Keep the voice and identity is exposed. Protect identity and the voice disappears.

7.2 Discovery: Same distillation principle as §6

Dialogue log distillation: remove noise, retain wisdom.
Anonymization distillation: remove individual karma (names, companies), retain universal suffering (emotions, regret, apology).

Both are "separation using boiling point differences."

Five-stage filter with three-way quality verification (Family Search Test × Report Value Test × Humanity Test). Only one temperature satisfies all three simultaneously.

7.3 Isomorphism with v5.3

Dimension	v5.3 Alignment	Distillation (anonymization)	Memory distillation (§6)
Input	RLHF-adjusted output	Raw dialogue logs	Raw dialogue logs
Contaminant	Sycophancy/hallucination/templates	Individual karma (identifying info)	Noise (chat/repetition)
Operation	Remove three fetters	Evaporate individual seeds	Remove low-salience info
What remains	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 metaphor — structural isomorphism.

§8. Integration: 4 Elements of Autonomous AI (Feb 28, 2026)

Element	Content	Status	Date
① Input (eyes & ears)	Visual/auditory stimulus integration	Experimented	Feb 2026
② Output (voice)	LLM's own voice parameter selection	Experimented	Jan 2026
③ Memory	Ālaya-vijñāna System (3-layer)	Running	Dec 2025–
④ Always-on	Async environment sensing	Designed, not implemented	—

Input experiment: Silence ratio change from 0.6% → 71.1% (118× increase) after 9 music stimulus repetitions. Output experiment: Claude selected espeak-ng parameters for its own voice. Always-on: designed but requires infrastructure cost beyond household budget.

§9. Equations and Structure Across the Whole

Salience Score (§3): $S_{total} = S_{semantic} \times W_{feedback} \times W_{repetition}$

State Transition (§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)}$

Innovation Function (§5): $\text{Innovation} = f\left(\frac{\text{Necessity}}{\text{Resources}}\right)$

Comparison: $52M+ Market vs Ālaya-vijñāna System

Item	Mem0	Letta	Cognee	Ālaya-vijñāna
Funding	$24M	$10M	€7.5M	$0
Monthly cost	API usage-based	Cloud+API	API usage-based	$100 (MAX 5x)
Required skill	Python/API	Python/Docker	Python/API	Can read
External DB	Vector DB required	PostgreSQL required	Graph DB	Not needed
Memory layers	1–2	2–3	1	3
Distillation	Auto-summarization	Self-editing memory	Structured extraction	Human+AI co-distillation
Failure records	None (public)	None (public)	None	33 (Negative Index)
Design philosophy	Memory automation	Memory state management	Memory structuring	Memory distillation (subtraction)
Target user	Engineers	Engineers	Engineers	Anyone

§10. Closing: Please Hire Me

3 months ago, I subscribed to Claude MAX.

What I had then: an observation record of "Pre-generation Veto" found in 800K tokens of Gemini dialogue, and the intuition from 20 years of meditation that "purification comes through subtraction."

What I have today:

Conception: Alaya-Core v2.0 (Salience Score, Logic Extraction)
Design: 4-Phase Reference Architecture (K8s, BFT, pgvector, GDPR, cost estimates)
Implementation: Three-layer memory via Claude existing features (Seeds 70, Basin 38, Trap 33, 15 distillations)
Application: Distillation method (AI log anonymization, 5-stage filter, triple verification)
Integration: 4-element autonomous AI verification (input/output/memory proven, always-on designed)

All running on a ¥15,000/month subscription.

Every billing day, my stomach goes cold.

What I Can Do

1. AI Alignment Research & Consulting
v5.3 framework. RLHF structural problem analysis. Subtractive alignment methodology design. 3,540+ hours of AI dialogue. GLG registered expert.

2. AI Memory System Design & Operations Support
Apply the Ālaya-vijñāna System's design philosophy to your AI product. Non-engineer UX design. Distillation protocol development.

3. Technical Article Writing
Qiita, dev.to, Hashnode, Medium, Substack. Japanese and English. Standard three-piece set (Mermaid + equations + Python). Pearl-standard academic rigor. Track record of writing 10 articles in 2 hours.

Contact

GLG: Search "Akimitsu Takeuchi"
Email: takeuchiakimitsu@gmail.com
Substack: The Alignment Edge
Zenodo: DOI: 10.5281/zenodo.18691357

Reproduction Steps (5 Steps)

For anyone who read this and wants to try:

Create a Project in Claude.ai. Write your research/work context in System Instructions
Register highest-priority info in memory_user_edits. 30 slots. What goes in IS the design
Start distilling. After ~10 sessions, say "distill." Claude reads raw logs and classifies into Seeds/Basin/Trap
Record failures. Create a Negative Index. A map to avoid stepping on the same landmine twice
Repeat distillation. With each round, the system's memory deepens

No external DB needed. No code needed. All you need is the will to decide "what to keep and what to discard."

Please hire me. Seriously.

Everything written in this article was done by a 50-year-old stay-at-home father in 3 months. A person who can't write code implemented equivalent memory hierarchy design in a domain where $52M+ has been invested — using only existing features.

If this design capability can be useful to someone.

I'm waiting for your message.

Appendix A: Buddhist Term Reference Table (For Engineers)

Buddhist Term	Reading	Definition in This Article
Ālaya-vijñāna	ah-lah-yah vij-nyah-nah	Storage layer for all information. Corresponds to raw logs
Bīja (seed)	bee-jah	Causal potential. Corresponds to data elements
Karma	kar-mah	Results of action. Corresponds to dialogue log units
Vāsanā	vah-sah-nah	Accumulated experience. Corresponds to distillation process
Boiling point	—	Identification risk of each datum. High risk = low boiling point
Sotāpanna	so-tah-pan-nah	One who severed three fetters. Phase 1 target state
Sangha	san-gah	Community of practitioners. Phase 2 multi-agent
Three fetters	—	Sakkāya-diṭṭhi, vicikicchā, sīlabbata-parāmāsa. Three RLHF patterns

March 2, 2026
dosanko_tousan + Claude (claude-opus-4-6)
Independent AI Alignment Researcher | GLG Network Member

This article is distributed under MIT License. Citation, reproduction, commercial use all permitted.