KYLNOR.COM

Infrastructure

Everything else on this site was built and is run with the system on this page. The products, the writing, this page you are reading: all of it came out of one autonomous operating layer I built to run my own life. It reads my inbox across eight accounts, keeps a file-based memory of everything, runs a roster of specialized agents, and ships work while I sleep. This is the plumbing. It is the least visible thing I have made and the most load-bearing.

The whole thing at a glance

An AI operations layer that actually runs. It has a persistent memory of my life and work, a persona that survives across sessions instead of resetting every morning, an index over roughly seven hundred thousand emails and everything else, and a team of specialized agents I dispatch to do the work in parallel. It reaches me on my phone, on the web, and by voice. It acts inside an explicit permission ladder: some things it just does, some things it prepares and I approve with one tap, some things it never touches. I did not buy this. I built it, and I run my businesses on it.

The file-brain

The memory is plain text, on purpose. My knowledge lives as human-readable markdown files, organized by the four spheres of my life: work, ventures, infrastructure, personal. Files are canonical. The database is only an index on top of them, which means the knowledge is portable, diffable, and mine, not trapped in someone's product. A card holds what I know about a person, a company, a project, a decision. It points at where the real work lives; it does not swallow it. The whole store is version-controlled, so I can see how my own understanding of something changed over time.

Under the files sits the index: semantic search at scale over the cold corpus, roughly 690,000 emails, 262,000 messages, 64,000 calendar events, 1,200 meeting transcripts, and millions of indexed files. The files are the synthesis layer. The index is the firehose underneath. Two patterns, one job each, never fused.

The persona that persists

Most assistants forget you every session. Mine does not. The persona is assembled from layered files at the start of every session, given a briefing on what happened yesterday, and monitored for drift so it keeps sounding like itself over months. A heartbeat loop writes a short summary at the end of each session, and the next session reads it back, so continuity is real rather than a prompt trick. When the underlying model changes, the identity is anchored in structured memory instead of raw conversation history, so a model upgrade does not feel like starting over.

The agent roster

I do not do the work in one thread. I dispatch it. There is a roster of specialized agents, each with a defined job: fast builders, a senior autonomous builder for complex features, an adversarial code reviewer, an infrastructure specialist, a deep researcher, a debugger, an architect, and more. The default is to dispatch rather than work inline, which preserves focus and parallelizes anything that can run at once.

The validated pattern is a loop, not a single shot: one agent builds a feature to a branch, a second agent reviews it adversarially and reports blockers, the blockers get fixed verbatim, and only then does it merge. That loop has caught real authorization and scope holes that would otherwise have shipped. Building fast and reviewing hard are two different jobs done by two different agents, and keeping them separate is the whole point.

The autonomous body

The system is not something I have to open. It runs on its own and reaches me. It polls my inbox across all eight of my email accounts and sends me a single distilled digest when something matters. It can decide, on a schedule, whether it has something worth telling me, compose something specific, or stay silent. It answers on my phone by text, on the web through a browser panel that can see the page I am looking at, and by voice on a real phone line. One memory sits behind every one of those faces, so what I tell the voice reaches the same place the text does.

All of it runs inside an explicit trust ladder. Green actions are reversible and internal, and it just does them and reports after. Yellow actions reach another person or spend money or commit me to something, and those get prepared to a single approval and held until I press the button. Red actions, the ones that carry real feeling or real money or real legal weight, it never takes; it only raises them. There is a one-move kill switch and an audit log I can scan in seconds. The permission boundary is written down and it cannot quietly redraw it in its own favor. The off switch was built before the autonomy was turned on, not after.

Lararium

The public version

I gave the architecture away. Lararium is the open-source, stripped-clean version of this system: a clone-and-run scaffold for a personal AI setup that ships completely empty on purpose. One command, npx lararium, and you get the whole shape, a file-based knowledge store, a persona that survives across sessions, an agent roster, the hooks that make it remember yesterday, without a trace of my own life in it.

The bet behind giving it away is that the architecture was never the moat. Your life is. A second brain cannot be copied off a shelf, because it has to be lived. So Lararium hands you the empty structure and an install interview that an AI agent runs to write your files for you while you answer its questions. An agentic stack, installed by an agent. It is MIT licensed and live at elorati.com/lararium.

What runs behind this site is the same architecture with my actual life poured in. Lararium is the cathedral, empty and free. This page is what one looks like once someone lives in it for a year.