Lararium

A lararium was the shrine in a Roman house where the household gods lived. The family kept it, fed it, and spoke to it daily. This is that, for a life run with AI: the shrine, and the gods you keep in it.

A clone-and-run scaffold for a personal agentic system. Six layers: a file-based knowledge brain, a layered soul (the assistant you actually talk to), a clocktower index over your data, a few plain agents for the jobs that earn one, the hooks that make it feel alive session to session, and the skills it runs as slash commands.

It ships empty on purpose. The architecture was never the moat: your life is. So you get the shrine, and you bring your own gods.

This is a template, extracted from a working private system and depersonalized. It ships structure, conventions, and hard-won patterns. It ships none of the original owner's data, persona, or secrets. See SCRUB.md in the upstream repo for exactly what was removed and how to verify nothing leaked.

Start here in five minutes

You do not need the six layers below to get value. The starter is a map file, three folders (notes/, people/, projects/) and a memory index: one topic per file, lowercase-hyphen names, and an assistant that searches before it answers. Get the folder first (see "Getting it onto your machine" below: npx lararium my-stack is the one-line route), open it in Claude Code and say:

Run the starter in starter/README.md

It interviews you, writes your first three notes and proves the memory works. Everything after that is optional and labelled "when you outgrow the starter".

Memory across agents

Files are the memory. Every agent CLI on your machine (Claude Code, Codex, Gemini CLI) is pointed at the same files, so what one learns the next already knows, and switching tools loses nothing. A short pointer block, installed into each CLI's instruction file by hooks/memory-pointers.mjs, says where the map is and how to search. Lessons live as one-fact cards in memory/ with a one-line index. Two things fill it: the shipped hooks carry the last conversation forward without anyone asking (Claude Code today), and the pointer block tells every agent to write a card when it is corrected. Streams from your mail and calls can feed it too, once you stand up the index. A search miss is reported as "not found in X", never "it does not exist". Doctrine in memory/README.md, install steps in INSTALL.md.

Why this instead of a prompt pack

Everyone else hands you their context: their prompts, their personas, their ten hacks. Lararium hands you the empty structure and teaches you to pour your own life into it. A second brain can't be copied off a shelf; it has to be lived. That is the whole design, and it is why giving this away costs nothing: nobody can steal a life they have to build themselves.

It also installs itself. You open it in an AI coding assistant and say "run the install interview." An agentic stack is installed by an agent. It interviews you, one question at a time, and writes your files while you answer.

When you outgrow the starter: the six layers

Optional from here on. Add a layer when its pain shows up. Two more optional pieces sit beside them: governance/ (a rule that retires old rules, plus a small constitution) and forge/ (briefs for agents that build), with workspaces/ for projects that have earned their own folder.

1. brain/: a human-navigable markdown knowledge store, scoped by life sphere, governed by a small set of laws (brain/CLAUDE.md). Files are canonical; the database is an index on top. The heart of the system, and the one to read first. Useful on day one with nothing but markdown.
2. soul/: the assistant's persona, assembled fresh each session: seven layered sections, a heartbeat loop that lets it remember yesterday, voice-drift monitoring so it keeps sounding like itself. Ships blank; soul/character-craft.md teaches the craft (archetypes, trait tensions, tone proofs). Its rules half lives in rules/OPERATING.md: action bias, the miss-capture protocol, steering rules, the standards.
3. clocktower/: the index: schema, an MCP server config, the watcher pattern that ingests your corpora, the embeddings standard, and the retrieval doctrine earned in production (clocktower/retrieval-doctrine.md). The memory layer has four organs, intake, carder, gate, and connector; the last is the daily "what I just learned maps to what I am stuck on" job, documented in clocktower/connector-doctrine.md. Coordination is a separate surface: clocktower/queue-doctrine.md runs multi-agent work natively on the tasks table you already have. Ships with an empty database and no credentials.
4. agents/: the dispatch doctrine and three plain defaults (a reviewer, a researcher, a verifier). Start with one assistant in one loop and put procedures in skills; add a subagent only when it earns its place. A full themed roster is an opt-in example that is not in a default stack: make the stack with npx lararium my-stack --with-examples, or browse it upstream. It comes with an interview for rebuilding it in a theme of your own.
5. hooks/: the loops that make it feel alive. Session-start briefing, the heartbeat that remembers yesterday, voice integrity, compaction continuity, safety rails, dispatch routing. Doctrine plus minimal reference implementations that run on plain files, no database required.
6. skills/: slash-command skills for the session lifecycle (/end, /handoff, /sessions), self-improvement (/evolve), and memory curation (/curate), plus the doctrine for writing your own.

Beside the six layers ships one optional tool: lab/, a disposable sandbox for untrusted code. Your assistant is most useful when it can clone and run other people's repos, which is exactly when it is most dangerous. The lab is a throwaway container, no network by default, nothing of yours mounted in, every capability dropped, that you drop untrusted code into so it can do its worst and it doesn't matter. The /in-the-lab skill runs it for you: offline recon first, then an optional deeper session. Requires Docker; skip it if you don't have a daemon.

Staying current is meant to be passive: your stack tells you when it is behind. Adopt the update-check hook (hooks/reference/update-check.js) and once a day, at session start, it checks the upstream template's version against your own STACK_VERSION and, if a newer release is out, drops one line into your session: type /upgrade. That skill fetches the latest template and runs the upgrade interview in UPGRADING.md for you, applying the doc-only deltas directly and asking you only about the structural ones. You answer questions; your assistant does the typing. The manual fallback, for a stack that has not wired the hook yet: Watch releases on the upstream repo and read CHANGELOG.md, where each release maps to an entry that classifies it as a doc copy-in or a full interview and names exactly which files moved since your own STACK_VERSION.

Getting it onto your machine

Prerequisite: an AI coding assistant that can read and write files in a local folder. The install interview writes your files for you, so it needs filesystem access. Claude Code is the reference setup (it brings its own subscription or API key). A browser chat can talk you through the interview but cannot write into your folder, so you would be copy-pasting; use the real tool.

Get the template locally. For a personal stack, npx is the route:

npx lararium my-stack  &&  cd my-stack

The scaffolder leaves out the files that only matter to people working on Lararium itself (its tests, CI workflows, contributor guide and blog). Two other routes exist, and both are copies that include those contributor files:

# GitHub template repo: click "Use this template" to make your own copy, then
git clone https://github.com/<you>/<your-copy>.git  &&  cd <your-copy>

# Sent a zip: unzip it, then
cd lararium

One cleanup line for those two. If AGENTS.md starts with <!-- lararium:contributor-file -->, remove AGENTS.md, SCRUB.md, CHANGELOG.md, npx/, tests/, docs/blog/, .github/ and agents/examples/ (keep that last one only if you want the themed agent roster). Your assistant does this for you as step 0 of the starter and of the install interview.

Wary of npx-ing a stranger's installer? Good instinct, it is the whole reason this stack exists. The scaffolder (npx/index.js) is about 200 lines of Node standard library with zero dependencies: it downloads a release tarball, unpacks it, and runs git init. It runs none of the template's own code. Read it before you run it, or skip it entirely and clone the repo by hand, then you have inspected everything before a single line executes.

And if you are properly paranoid: the two files worth eyeballing are both short (npx/index.js and lab/lab). Read those, then let your very first lab run be Lararium itself:

lab/lab https://github.com/kylnor/lararium

That vets the rest of the stack inside the box it ships. The tool's first job can be auditing its own supplier.

Then open the folder in Claude Code (claude from inside it) and start with the five-minute starter in starter/README.md:

Run the starter in starter/README.md

When you outgrow it, the full setup is the install interview:

Run the install interview in INSTALL.md

Either one is the setup step; downloading alone does not configure your assistant. Before adding optional layers, open a fresh conversation in the same folder and ask: "Read brain/CLAUDE.md and brain/now.md, then summarize my current priorities and name the files you used." This checks that your saved context can be read. Memory is on from the first conversation: the folder ships two hooks that save the end of each conversation and hand it, with brain/now.md, to the next one opened in the same folder. Say yes when Claude Code asks whether you trust the folder, or they do not run. It remembers the last conversation, not every conversation; anything worth keeping longer goes on a card.

The brain and soul layers use plain files. The index (clocktower) is optional and wants your own database and embedding key, the day you decide you want search at scale.

Verify your memory

Run node hooks/memory-check.mjs . from your installed folder to check the standard memory files. Then follow the memory check: save a test preference, retrieve it in a fresh conversation, correct it, and retrieve the correction. File checks alone do not prove automatic loading or conversation capture.

Setup order (if you would rather do it by hand)

Start with the brain: useful immediately, zero infrastructure, just markdown and the laws. Add the soul when you want a consistent voice, its rules half with it. The two memory hooks come wired (.claude/settings.json); wire the others when you want them. The reference implementations run on plain files. Add clocktower when the file layer outgrows grep-and-read and you want semantic search at scale. Agents and skills last: leverage on top of a system that already works.

1. Read  brain/CLAUDE.md          # the laws, the map
2. Fill  brain/now.md             # your cross-cutting heartbeat
3. Write soul/core.md             # your assistant's character (replace the blank)
4. Adopt rules/OPERATING.md       # the operating rules, edited until true of you
5. Wire  hooks/                   # the loops: briefing, heartbeat, rails
6. Adopt skills/                  # the session-lifecycle slash commands
7. Stand up clocktower/           # optional: the index, when you need it
8. Adopt agents/                  # optional: three plain defs + when a subagent earns its place

Already running an earlier version? Open your stack beside this template and say "run the upgrade interview in UPGRADING.md." It adds the new layers without touching anything you made yours.

What this is not

Not a hosted product, not multi-tenant, not a SaaS. It is a personal system you run yourself, shaped so a peer can clone it and make it theirs. The productized version is a different and much larger build. This is the shrine, free. What you enshrine in it is the part only you can make.

MIT licensed. Built in the open from a system that runs a real life. Bring your own gods.