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. A wiki built on the metabolism axiom looks different from a wiki built on the filing one.

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 PKM tools I’d tried (Obsidian out of the box, the dozen graph-view experiments, the “second brain” templates from every productivity creator on the internet) all treated notes as files. A folder, a tag, a search bar, maybe a graph view. Build a couple thousand of them and you have a stack, not a system. 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, the metaphor pulled all the way down: 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 with a tier and a status, each consulted in a different order depending on whether the system is ingesting, querying, or linting.

The ritual commands aren’t decoration either. hiho opens the morning. !loopcheck audits a thread. !canon audit gates changes to the nucleus. They’re speech-acts in Austin’s sense: utterances that perform the thing rather than describe it. Naming a state is what moves the system into that state. Language is the interface; the vault has no buttons.

A loop is one thread of work or thinking: a project, a question, a habit, an open conversation. Each one has a lifecycle:

• 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.

Five states, one direction, no resurrections without a reason. Most knowledge systems fail by piling up. This one treats pruning as success and lint as a regular Tuesday. The compost step is doing the most work in that sentence. Composting isn’t deletion; it’s a memory ethic. The loop stops asking for attention without being punished for stopping. Dormancy gets a place to go.

Layered over the parts and the loops, a rhythm: three states the system cycles through, each with its own rules about what’s allowed. The metaphor doesn’t stop at anatomy.

the schema

Underneath the metaphor is a schema. The vault runs on a three-layer pattern (raw / wiki / schema), three operations, one schema file at the root that tells the model how to behave. The metaphor and the schema are two languages describing the same shape.

Three layers:

• 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, findings passes, seeds, loops, lore, the canon. The model writes here, I curate.
• The schema: 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 (chat, article, voice memo) into the wiki. Read fully, surface the top three takeaways, wait for confirmation, then touch 5–15 wiki files and append to log.md.
• Query asks a question against the wiki and synthesizes across pages, with citations to file paths and line numbers, and an option to file the answer as a new FAQ or concept page if the insight is canonizable.
• Lint is the weekly health check (orphan pages, broken wikilinks, frontmatter gaps, schema drift, canon contradictions, stale blooms past the 21-day threshold), reported as a prioritized 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: Bush’s Memex, Engelbart’s NLS, Nelson’s Xanadu, Luhmann’s Zettelkasten, the current Roam-and-Obsidian generation, the AI-PKM cohort (Mem, Tana, Reflect, Heyday), the agent-system literature (AutoGPT, crewAI, MemGPT).
• Human science, the ground the cell metaphor sits on: Austin’s speech-act theory, Barkley on ADHD and time-blindness, Clark and Chalmers on the extended mind, Porges’ polyvagal theory, Ricoeur on narrative identity.

Each note carries a Tier (1 for the page that anchors something, 4 for context), so when a session is short, Tier 1 first is the rule and the rest can wait. Research piles up otherwise.

The synthesis doc does the most work: a Similarity Map that puts Golden Cell against the prior art in three columns:

• Novel: what’s worth protecting (biology-as-literal-architecture married to AI agents, ritual command language as UI, an explicitly affective layer).
• Familiar: what to borrow rigor from (autopoiesis from Maturana and Varela for technical vocabulary, the Viable System Model from Stafford Beer for the five-system check, MemGPT for hierarchical memory).
• Trap: failure modes the literature has documented, so the project can dodge what killed its predecessors:

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 (accumulating notes you never return to) 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. Without the synthesis, the cell metaphor is an aesthetic choice; with it, the metaphor is defended against the documented ways it could fail.

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. The shape of the output, with paths and counts elided:

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.

The whole vault is a couple thousand markdown files; the schema is one. The schema is what lets the couple thousand stay coherent across sessions where the model running them has no memory of the last one.

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 otherwise: 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 (a biological metaphor and a clean engineering brief), the same shape underneath. The pattern is real, not personal idiosyncrasy.

Bursty attention and unfinishedness aren’t bugs to design around. Most knowledge systems treat them as drift to be corrected: drag the user back into linear queues, uniform tasks, finish-or-fail completion logic. Golden Cell starts from the other end. Memory, sequencing, transitions, reflection get pushed into the environment so the thinker doesn’t have to carry them all at once. Cognitive offloading, but as architecture rather than apology.

It’s an instrument, not a SaaS. Tuned to me. The architecture travels; the contents don’t. The agents, the lore, the canonical entries are mine and won’t survive being lifted out of my hands. What does travel is the grammar: decay as a feature, pruning that preserves revival paths, AI roles that are specific rather than an assistant, compression as a form of care, ideas modeled as processes rather than objects. It isn’t a better filing cabinet. It’s a small weather system for thought.

what would prove it

Three hypotheses I’d test in a thirteen-week window if I were treating Golden Cell as a runtime instead of a vocabulary:

• The lifecycle moves under load. Five states (Seed → Bloom → Vine → Organism → Compost) is good language. It’s untested as a runtime. Pick one bloomed seed, force it all the way through to Organism (or to Compost) within thirteen weeks. If the lifecycle holds, the metaphor is operational. If the seed sits in Bloom for thirteen weeks because every state transition is meta-work, the metaphor is decorative.
• Executive Trust Score is the only metric that matters. A single number, rated weekly: do I trust the system to hold what matters? on a 1–7 scale. One boring metric tracked for thirteen weeks beats five beautiful ones never touched. The bet is that the score either stabilizes (the system holds) or visibly drifts (something is leaking). Either result is information.
• The self-healing engine logs a real catch. The lint operation is documented. The immune-system framing is documented. Neither has caught and repaired an actual canon contradiction or stale bloom in production yet. Until one does, the engine is a design spec wearing a runtime label. The proof is one logged event, dated, with the entry that triggered the catch and the repair I made.

Two risks the project has to keep watching:

• Meta-work as the work. The vault has enough internal richness to keep generating architecture indefinitely. The Trap column already warns about grand unified systems don’t ship; this is the local version of that risk. Without a forcing function (the thirteen-week window, the single bloomed seed, the logged catch), the project becomes a beautifully documented record of itself. Tracking signals mitigates this; it isn’t a forcing function.
• Named-entity bloat. Twenty-five named helpers is the system’s brag and its liability. The vault’s own backlog already names a consolidation pass on roughly thirty percent of them. Until the pass happens, invocation is magical in the bad way (memorable only to me, who named them). Pruning agents is the same discipline as pruning blooms; the cell metaphor demands telomeres on the named parts too.

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.

method extracted: Golden Record

Golden Cell is the larger personal system. Golden Record is the simpler reusable pattern. Separate canonical memory from working notes, experimental loops, and archived material. This keeps a system useful instead of merely large.

Related method: Golden Record.