Building a Second Brain: Why I Made a Personal AI Assistant

There are a lot of apps and tools out there for daily life, and a good chunk of them exist to save your brain the work of remembering things. I use plenty of them myself, for writing notes, journaling, tracking wellbeing, tracking my job search, doing research, and managing whatever else needs managing. Sometimes I want to go back to one specific idea or question I had, and I can't remember where it was. I feel like an archaeologist digging through old chats, files, and notes just to recover one specific thing. Claude and ChatGPT are getting better at remembering things about me, but that memory is thin, fades over time, and stays locked inside one tool. It doesn't help me find something I wrote somewhere else entirely.

All of these tools are connected to my actual life, but each one lives in its own silo. I offloaded my own memory onto them so I wouldn't have to hold everything in my head, and it worked, in a way. It just replaced one problem with another. Now the thing I can't remember isn't the idea itself, it's which tool I put it in.

The problem

I had notes scattered across a notes app, a separate wellbeing tracker, journal entries in yet another place, and one-off conversations with AI chatbots like Claude or ChatGPT that forgot all of it whenever I started a new session. Nothing talked to anything else. If something mattered, I had to remember which app it was in, or it just got lost between them.

The goal was a second brain: one organized system to store all of that in one place I fully own, as plain text I could still read with nothing but a basic text editor years from now, instead of fragmented across tools that don't talk to each other and can't recall anything on their own.

Storage alone doesn't fix fragmentation either. It just becomes one more place things sit. Something still has to actively put things in, consistently, and actively pull the right things back out when they're relevant. So I built a personal AI assistant to be that active layer. It handles the logging and the recall, while the second brain holds what's actually stored.

I built it on NanoClaw, an open-source framework for running a personal AI agent in isolated containers, self-hosted on a small Hostinger VPS. Claude Code did the actual implementation work. I described what I wanted, and it wrote and wired up the pieces. The agent itself I call Iris, and I talk to her over Telegram to log check-ins, pull up past context, or work through whatever else is on my plate.

How the agent has evolved

It grew outward from that starting point, into career material, family tasks, and reminders, as its knowledge base grew and the underlying models kept improving. Wellbeing stayed the core on purpose even as the scope around it expanded.

At one point I split it into specialized personas: one for career, one for wellbeing, one for writing, and an orchestrator to route between them. It seemed like the right way to keep each domain focused. In practice, it recreated the exact problem I started with, just moved from apps to agents. I collapsed it back down to one persona, Iris, handling everything.

The other kind of change is smaller and constant. I notice a bug or something I don't like, or think of something to add, and work through it with Claude Code. I describe the problem, and it makes the change. One example: an approval that looked completely successful had quietly been writing a memory update to the wrong location for two weeks before I caught it. Not an AI mistake in any real sense. An ordinary software bug, the kind you'd find in any system, that happened to involve a language model instead of a hand-written function. I fixed the routing and added a check so it can't silently happen again.

Most of the changes look like that. Not a redesign, just noticing something and fixing it.

What it looks like today

Logging and recall

• Logging: I send it a rough, half-formed check-in over Telegram, and it turns that into a structured entry in the second brain, sorted into the right place, in the right format, and linked to related past entries where they connect, reliably, every day, without me having to remember to open a notes app, file it, or go find what it relates to myself.

• Recall: when it needs context, it reads back across months of stored entries and surfaces what's actually relevant, connecting something happening today to something similar from a while back, instead of me having to remember and go dig it up myself.

Logging isn't just capture. It's capture, organize, and link, all in the same step. That linking is what makes recall possible later, rather than something bolted on afterward.

Day to day

• Talks over Telegram, no separate app to learn or open

• Prompts me proactively with a daily check-in nudge, instead of waiting for me to remember to write something down. I'm not limited to those moments either; I can message it anytime, day or night, and it's there

• Handles pretty much whatever's on my plate now: pulling up career and experience context when I'm reviewing a job post, keeping track of doctor's appointments, managing to-do lists, handling family reminders

• Keeps a short, curated summary of what actually matters, separate from the full day-to-day archive, so recall isn't re-reading months of raw notes every time it needs context. It's more like relying on a well-kept table of contents instead of re-reading an entire book

None of that lives in a separate app or a separate thread. It's all just Iris.

The design decisions that actually mattered

The AI answering questions well was never the hard part. That's mostly solved already. The decisions that made this trustworthy rather than unsettling were all about the plumbing around it:

• Everything I write lives as plain text I own, not locked inside a proprietary app.

• The archive and the curated summary are two different things, on two different schedules. The full history captures everything in detail; the summary holds only what's worth remembering at a glance.

• Nothing gets saved to that summary without my sign-off. Every proposed update gets shown to me first. If I ignore it, nothing breaks. It just carries forward and gets reconsidered next time, rather than silently going stale or silently applying itself.

• Each conversation runs in its own disposable workspace, set up fresh and torn down afterward, with access to only what that specific conversation needs. Nothing lingers between conversations, and nothing has more reach than the task in front of it requires.

What's next

There isn't a fixed roadmap here. As I keep using Iris and she learns more about me and my activities, I'm sure I'll find new ways to optimize the system or new use cases to add to what she can do.

It started with a wellbeing tracker

The first version was just a wellbeing tracker. Three scheduled check-ins a day, logged. Those check-ins got organized into daily reports, and I could write journal entries that cross-referenced each other. That was the whole system.

Wellbeing was the deliberate starting point, not an arbitrary one. How I'm actually doing determines how I go about the rest of my day and everything in it, so it made sense to anchor the system there before building anything else on top.d fixing it.