Golden Cell

In plain terms: an Obsidian vault that thinks of itself as a body. A personal LLM-OS in cell-biology vocabulary. Rules for what gets in, what matures, what gets composted, when to rest.

Status

ongoing

Stack

Obsidian

Notes

~2K

Agents

25

Hard part

pruning as success

why

Most knowledge systems start from the assumption that thought wants to be filed. I started from the opposite one: thought wants to metabolize. It arrives unfinished, moves nonlinearly, returns at strange angles, and depends on attentional and emotional state in ways the file-folder-tag idiom can’t see.

I wanted a wiki that worked like an organism, not a folder: a metabolism for the notes themselves, where things mature, decay, get composted; a regulatory rhythm so the whole thing knows when it’s resting and when it’s expanding; specialist roles that delegate work the way a cell delegates to its organelles. The biological-cell metaphor was the constraint that decided what got built and what didn’t.

Golden Cell is a system from and of my own mind. The architecture travels; the contents don’t.

What I didn’t know, building this in August 2025, was that this would later have a name. Andrej Karpathy posted a gist for the same three-layer pattern (raw / wiki / schema) a few months later, and the gist went viral. Two starting points — a biological metaphor and a clean engineering brief — the same architecture. Convergent invention is the louder signal that a pattern is real.

how it works

The vault is shaped like a cell: a membrane that decides what gets in, a cytoplasm where active projects metabolize, ribosomes that spin live loop work, telomeres that handle compression and rollback, and a nucleus that holds the decisions which survive amnesia. Five parts. One job each.

The named parts have jobs. Gatekeeper lives in the nucleus and refuses changes to canonical entries without a !canon audit ceremony. LoopBot and LoopCheck are ribosomes: they spin a thread of work into a structured loop and audit whether it’s still moving. SnapBack is a telomere: when a session goes wrong, it rolls back to the last clean state. Maniac, ALCI, and the Golden Record Coach sit at the membrane — how I meet the system on a given morning, mood-dependent. Twenty-five named helpers in total, each consulted in a different order depending on whether the system is ingesting, querying, or linting.

A loop is one thread of work or thinking: a project, a question, a habit, an open conversation. Five states, one direction:

• Seed: a frontmatter stub with a RICE score and a domain tag.
• Bloom: the seed earned return-attention and grew into a real page.
• Vine: the bloom grew beyond one page, with cross-links into multiple folders.
• Organism: the vine stabilized and shipped, a finished thing with a fixed shape.
• Compost: the organism’s done, or a bloom didn’t make it past 21 days untouched. Archived, lesson kept, loop closed.

Most knowledge systems fail by piling up. This one treats pruning as success. Composting isn’t deletion; it’s a memory ethic. The loop stops asking for attention without being punished for stopping.

the schema

Underneath the metaphor is a schema. The vault runs on a three-layer pattern (raw / wiki / schema), and the metaphor and the schema are two languages describing the same shape.

Raw sources (852 chat transcripts, a Notion import, a repo dump) sit immutable in Chats/, Notion_Import_Clean/, Repo/. The model can read them and never write them, full stop. The wiki — architecture pages, agent pages, project pages, seeds, loops, lore, the canon — is where the model writes and I curate. The schema is CLAUDE.md at the root: the one document the model reads first every session. Defines folder purposes, frontmatter conventions, safety rails, voice rules, and the three operations themselves. Schema and wiki co-evolve. Raw is sacred.

Three operations: Ingest processes a new source into the wiki. Query asks a question across the wiki and synthesizes with citations. Lint is the weekly health check — orphan pages, broken wikilinks, frontmatter gaps, stale blooms — reported as a punch list, never auto-fixed. Every operation logs itself. The vault writes its own diary.

the research layer

The vault has eighteen comparative notes in Research/, organized into two lineages: information systems (the ancestors and contemporaries, from Bush’s Memex through the current AI-PKM cohort) and human science (the ground the cell metaphor sits on). Each note has a Tier so when a session is short, Tier 1 first is the rule.

The synthesis doc does the most work: a Similarity Map putting Golden Cell against the prior art in three columns — Novel (what’s worth protecting), Familiar (what to borrow rigor from), and Trap (failure modes the literature has documented):

1. Grand unified systems don’t ship. Xanadu, Memex, countless PKM startups.
2. The tool becoming the project. Usage volume beats system elegance, every time.
3. AI-PKM is a graveyard. Mem, Heyday, Dot: don’t position as “AI PKM.”
4. Collector’s fallacy. 852 captured chats, few re-used.
5. Agent hallucination. Autonomous loops drift; keep human-in-loop.

The traps column is the one I re-read most. Collector’s fallacy is exactly what 852 archived chat transcripts could turn into without an active lint loop. Naming it in the research layer is part of what keeps it from happening.

the receipts

The vault’s CLAUDE.md is the schema file the model reads first every session. The folder-purpose table, verbatim: twelve folders, twelve one-line answers:

Architecture/   How the system works — the structural concepts
Agents/         Named agents (orchestrators, guilds, execution)
lauraOS/        The ritual/command shell modules
Lore/           Mythology, metaphor, theology, beliefs
Projects/       Cytoplasm projects (Hosette, Flora, Music, Brotocol)
Meta/           Governance, findings, FAQs, audits, KPI log
Research/       Comparative work, Thesis, Similarity Map
Reference/      External bibliography (Wikipedia-linked)
Seeds/          Raw ideas with RICE frontmatter, pre-bloom
Loops/          Blooms, Vines, Organisms, Compost Log
Strategy/       Outward-facing positioning
Chats/          852 raw chat transcripts — immutable

The first row, Architecture/, is where the spine lives. Filtered to tag:#architecture in Obsidian’s graph view, it looks like this:

One of the schema’s safety rails: the rule that distinguishes the immutable-source layer from the wiki layer:

Hard rule: never modify files in Chats/, Notion_Import_Clean/, Repo/, or _Archive/ without explicit instruction. These are source of truth.

A lint run produces a prioritized punch list, worst-impact first:

LINT — <YYYY-MM-DD>

ORPHANS (n)
  <path>                            no inbound links

BROKEN WIKILINKS (n)
  <path>                            → [[<missing-target>]]

FRONTMATTER GAPS (n)
  <path>                            missing: <fields>

SCHEMA DRIFT (n)
  <path>                            <field> not in enum

CANON CONTRADICTIONS (n)
  <pageA> vs <pageB>                <one-line diff>

STALE BLOOMS (n past 21d)
  <path>                            last touched <YYYY-MM-DD> (<n>d)

COMPOST CANDIDATES (n)
  <path>                            closed <n>d, no incoming references

— punch list, not a fix list. nothing was changed. —

Output goes to Meta/log.md. I act on it, or I don’t.

what I learned

A metaphor is only worth keeping if it forces decisions. The biological frame killed several “obvious” features — a fixed taxonomy, a single dashboard view, a plug-in marketplace — because those things don’t have a cellular equivalent. Same metaphor-as-constraint discipline as the Periodic Table’s coordinate system. It also surfaced features I would have missed: telomeres for note-aging, a self-healing engine for broken links, a rhythm that says when not to add anything new.

A wiki built like this is more demanding to maintain than a folder of notes. It also remembers things a folder doesn’t. The trade has been worth it.

Convergent invention is the louder validation. I built Golden Cell because the existing PKM tools didn’t fit the way I think. Karpathy’s gist arrived a few months later with the same architecture. Two starting points, the same shape underneath. The pattern is real, not personal idiosyncrasy.

It’s an instrument, not a SaaS. Tuned to me. The architecture travels; the contents don’t. What does travel is the grammar: decay as a feature, pruning that preserves revival paths, AI roles that are specific rather than an assistant, ideas modeled as processes rather than objects. It isn’t a better filing cabinet. It’s a small weather system for thought.

the recipe

The architecture is generalizable; my contents aren’t. A starter prompt for someone who wants to build their own (the system you stand up will look nothing like mine, and that’s the point):

You are helping me build a personal operating system on top of Obsidian
(or Notion, or a folder of markdown files). The metaphor is biological:
a cell with parts that do specific work, separated by a membrane,
regulated by a rhythm.

A loop is one thread of work or thinking: a project, a question, a
habit, an open conversation. It has a name and a status: active
(moving), dormant (paused, may return), or closed (done, with the
lesson kept). The whole system is a way of tending loops.

We're not building a productivity app. We're building a system that
knows what gets in, keeps the decisions that matter steady across
sessions, knows when to rest, archives closed loops instead of leaving
them lying around, and delegates work to specialist roles instead of
one general thinker.

For each part below, ask me one or two questions, then write a short
markdown file I can save to my vault.

1. THE MEMBRANE. What gets in, what stays out.
2. THE NUCLEUS. Three to five core decisions enforced on every
   turn.
3. THE RHYTHM. Two or three states I move through. Don't suggest
   "rest / work / play"; ask me what shape my day actually takes.
4. THE AGENTS. Three to five specialist roles. Name them yourself.
5. THE ARCHIVE. Where closed loops go. A one-page log format that
   captures the lesson without keeping the loop alive: name, why it
   ended, what was learned, the condition under which it could return.

End by giving me a single _index.md that links the five files, and one
daily prompt I can run to check in with the system.

Ground rules:
- The metaphor is a constraint, not decoration.
- Don't suggest a brand name. The system is mine.
- Don't add anything I didn't ask for. Three roles is enough.
- Markdown only.

Three cycle prompts go with it: a daily recenter, a weekly loopcheck, a close-out for ending loops. Download the full kit as a single .md.

Related method: Golden Record.