Building a Second Brain

I finally got around to watching the Microsoft Build keynote. I usually do not watch those things live anymore. I end up watching them in pieces while I am doing something else, and this one was no different. Eventually I got to the part where Scott Hanselman announced OpenClaw coming to Windows, and the room reacted like that was one of the bigger moments of the keynote. I had never heard of OpenClaw, so I paused long enough to look it up, and that is usually how I end up losing two nights to a project I did not know existed that morning.

The first thing I did was try to understand what OpenClaw actually was. Not the marketing version. Not the demo version. I wanted to know what it could run, what it could touch, how agents were configured, what kind of scripts it could execute, and whether it was something I could use on a machine I already owned. I read documentation, watched videos, and kept coming back to the same thought: this looks like something I could stand up pretty quickly. One thing people do not realize is that "this looks easy" is not the same as "this will stay simple." A tool can be easy to install and still create a lot of long-term complexity if it is allowed to start touching everything.

The reason I cared about OpenClaw was that I already had Brainwav in my head. Brainwav was supposed to be my second brain. I wanted one place for fleeting thoughts, book notes, blog ideas, work priorities, family memories, recipes, random project ideas, and anything else that I knew I would forget if I did not put it somewhere. I already liked Obsidian and Markdown for this because plain files are boring in the best possible way. If I am trying to build something I can reference years from now, I do not want the whole thing trapped inside some app that may or may not exist. Markdown gives me files I can open, search, back up, sync, and move around without asking permission.

I had an old gaming PC in my office that was basically waiting for a purpose. It had been used for servers, extra storage, Linux experiments, and whatever else I felt like throwing at it. The GPU was too old to be useful for anything serious with AI, but the box still worked, and I was not using it for anything important. That made it the obvious place to start. If I wrecked the setup, I could wipe it and start over without taking down my actual computer.

The first install attempt was rough enough that I stopped trying to preserve the machine. I wiped it and installed a fresh copy of Ubuntu. That was the correct decision, and I should have made it earlier. I was trying to save time by working around whatever old packages, config, and half-finished experiments were already on there, but all that did was make the problem harder to reason about. If I am going to use a machine as personal infrastructure, I need to know what is on it. Starting with a clean OS gave me a baseline, and after that OpenClaw was not bad to get running. In a short amount of time I had agents running, a web interface up, and eventually Cloudflare pointing one of my domains at it.

That is the first thing I want to remember: when the machine is not doing anything important, wipe it. Do not be sentimental about old installs. Do not spend three evenings debugging stale package state just because the machine technically boots. If the point is to build a system I am going to rely on, the beginning state matters. A clean slate is not fancy, but it removes a bunch of variables that have nothing to do with the actual project.

After OpenClaw was running, I ran into the usage-limit problem pretty quickly. I was using GPT heavily because I was not just asking one-off questions. I was thinking through workflows, asking how to structure them, having it generate prompts, revising those prompts, and then feeding the refined prompts into OpenClaw. My first answer was to use the API. That worked, but it worked exactly like you would expect: once the workflow becomes easy enough, you use it more, and then the calls add up.

That is when I started looking at Ollama and local models. I wanted to see if I could move some of the simpler work off GPT and onto hardware I already owned. The Linux box technically ran a local model, but it was not useful in the way I needed it to be useful. It did not have enough RAM, the GPU was not helping, and the CPU was doing all the work. The result was something I could say was running, but not something I actually wanted to wait on. I moved Ollama to my MacBook, and that worked much better for simple things, but it still was not GPT-5.5. So the practical workflow became boring: use GPT-5.5 for the hard reasoning, use local models when I was near limits or when the task did not need the better model.

One thing people do not realize about local AI is that local does not automatically mean better for a personal system. Local can mean private, cheap, and available, which are all good. It can also mean slow, inconsistent, and frustrating if the hardware is wrong for the job. For Brainwav, speed matters because capture has to be almost effortless. If I have a thought while walking around or driving and the system makes me wait, I will stop using it. The best architecture is not the one that sounds pure. It is the one I will actually use.

The Brainwav idea started with a Slipbox. I wanted to capture verbal notes and have the system help decide what kind of note it was. Sometimes it would be a random thought. Sometimes it would be tied to a book, a blog post, a video, a work project, or something I wanted to revisit later. If the note came from a source, I wanted the system to preserve enough metadata that I could find that source again. If it was just a personal thought, I wanted it filed in a way that made sense without forcing me to sit down and organize it immediately.

The important part was that the permanent note still had to be mine. This is where automation can ruin the whole thing while looking like it is helping. The Slipbox method is not valuable because you stored a lot of text. It is valuable because you took something in, thought about it, put it in your own words, and connected it to other thoughts. If an agent reads a source and creates a polished permanent note without me doing that work, then it skipped the part where the value is created. That is not a second brain. That is just generated paperwork with a better folder structure.

OpenClaw solved the capture problem. I do not like having to sit at a keyboard every time I want to record something. I also do not want to thumb-type a paragraph into my phone just because an idea showed up while I was walking around. Voice capture changed that. I use Wispr for a lot of writing now, and talking through thoughts made the whole project feel possible. It also created a new problem: once I could capture thoughts quickly, I started having more of them, and once OpenClaw could implement workflows quickly, I started implementing more of those too.

At that point the system split into two parts. OpenClaw was the operating layer. It handled agents, scripts, scheduled tasks, Telegram integration, the web interface, and whatever else needed to move files or trigger workflows. Brainwav was the data layer. It was mostly Markdown: books, notes about family and friends, work events, current projects, day-job priorities, nighttime projects, hobbies, recipes, and anything else I wanted Future Jed to remember. That division still makes sense to me. The problem was not the idea. The problem was that I let the operating layer grow faster than my understanding of it.

The best workflow for building new pieces was not writing scripts myself. It was talking through the problem with ChatGPT, usually by voice, until I knew what I wanted, then asking ChatGPT to produce a detailed prompt for OpenClaw. OpenClaw would take that prompt and make changes on the Linux box. Once Telegram was wired in, it got even easier because I could send messages into specific Telegram topics and route them to specific workflows. This was extremely useful, and that is why it became a problem. Useful tools get used. Fast tools get used faster.

After a while, I had more moving parts than I could explain from memory. There were backups, metadata extractors, health monitors, databases, Telegram workflows, email workflows, daily briefings, copied files for rollback, old scripts that had been replaced but not deleted, and automations that were doing slightly more than I remembered asking them to do. Each piece made sense when it was created. That is the trap. Systems do not usually become confusing because one obviously bad thing gets added. They become confusing because twenty reasonable things get added without a rule for where they live, what owns them, or how to turn them off.

One thing people do not realize about agent-built software is that the code working is only one part of the cost. The other cost is whether I still understand the system a week later. If I cannot explain what a script does, when it runs, what files it can touch, and how to disable it, then I do not really own that workflow. I may have access to the file, and I may have asked for it, but that is not the same as understanding it.

The moment that forced me to slow down was opening my Slipbox and finding permanent notes I had not written. They were not terrible. That was part of why it bothered me. They looked normal enough that I could have left them there and moved on, but they were not mine. The entire point of Brainwav was to help me remember and think. If it starts producing finished thoughts for me, then it is doing the part I specifically wanted to protect.

So the correction is pretty straightforward. I am not backing away from OpenClaw, and I am not killing Brainwav. I still think personal software like this is worth building because nobody else is going to build a system that understands my work projects, my family notes, my reading, my hobbies, my half-finished automations, and the archive I want to leave behind someday. But I need rules now. Capture can be automated. Routing can be automated. Metadata can be suggested. Permanent notes need a human step. If something is going to live in the Slipbox as one of my thoughts, I need to have actually thought it through.

The next phase is not adding more impressive features. It is inventory. I need to go through the Linux box, name the workflows clearly, delete stale scripts, separate capture from interpretation, document what each automation is allowed to touch, and make sure everything has an off switch. That is less fun than making the system do a new trick, but it is the part that keeps the system mine. OpenClaw made it easy to build something powerful. Now I need to make it boring enough to trust.