What six months of living in ThoughtOS taught me

Six months ago, I started building a second brain. Not a notes app, and not another folder of documents I'd never open again — an actual memory layer that every AI I use can read from and write to. I called it ThoughtOS.

At first I thought the goal was productivity: move faster, capture more, waste less time. Six months in, I think the real reason is bigger than that. The point of ThoughtOS isn't to remember everything — it's to stop losing the context that makes the work meaningful. Every person, project, decision, and half-formed idea carries context, and most of it lives in our heads, scattered across tools, or buried in old chats. ThoughtOS gives that context a place to live, so the things I know keep working for me instead of being rebuilt from scratch every time.

This is the honest account of what changed, what didn't, and what I'd tell anyone thinking about working this way.

The re-explaining tax

I run technology across a group of related companies. On any given day I'm moving between a leadership meeting, an IT fire at one company, a design-and-build project at another, and three half-finished ideas somewhere in between. The context that makes me useful — who's who, what we decided last month, which client a piece of work belongs to, how a particular person likes information summarized — lived mostly in my head and across a dozen disconnected tools.

The breaking point wasn't a disaster. It was the small tax I paid every single day: starting over. Every new AI chat began from zero. Every recap meant reconstructing decisions from memory. Every "wait, which company was that for?" cost me ten minutes. None of it was catastrophic, but all of it added up — and it pointed at something I'd had backwards. The bottleneck was never a lack of information. It was access to the right context at the right moment.

Meetings stopped evaporating

The first real shift was also the dullest: I started capturing decisions as they happened — not transcripts, decisions. What we agreed, where a thread stands, who explicitly owns the next step, and, just as importantly, leaving the owner blank when nobody actually claimed it.

That last part matters more than it sounds. A lot of tools invent action items because they want everything to look complete, but real meetings are messier than that. Sometimes there's a clear decision; sometimes there's just an open question; sometimes nobody owns the next step yet. Capturing that honestly is more useful than forcing false clarity. I also taught the system how I like recaps for different rooms — leadership wants a scannable summary of decisions, not a punch list of inferred tasks — so the recap now comes out right the first time instead of after two rounds of edits.

The connections surface on their own

Working across several companies means the same person, project, or idea shows up in different contexts wearing different hats. ThoughtOS quietly holds that map: which person belongs to which company, which work is billable to whom, which "partner" is actually being treated as a client, which idea started in one place but now affects another. So when a piece of work touches two companies at once, the crossover surfaces instead of slipping through. I used to be the only place those connections lived — now I'm not the single point of failure, and that's been a bigger relief than I expected.

The freedom to be present

The gift I didn't see coming was freedom. Before this, I carried too much context in my head — not because I wanted to, but because I had to. I had to remember where the last notes were, what we'd already decided, who connected to which project, and what I still needed to ask someone the next time they were in front of me.

So I'd be physically in one meeting and mentally halfway into the next. Am I ready for the 2:00? Where did I put those notes? Was there something else I needed to ask this person? Didn't this connect to another project? That kind of load is quiet, but it's exhausting, and it pulls you out of the room you're actually in. I've walked out of meetings and realized an hour later that I forgot to ask something important, simply because it belonged to a different project. The person was right there. The connection just didn't surface at the right time.

Now the relevant context is served back to me when I need it — the people involved, the related work, the previous decisions, the loose threads that might matter. I don't have to keep all of that alive in my head anymore, so I can actually focus on the person and the decision in front of me.

In Claude, already up to speed

This is the part that surprised me most. Because the context is known everywhere, I can drop into a fresh AI session and start building almost immediately — it already has the projects, the people, the decisions, and the way I work. I'm not spending the first twenty minutes setting the stage; I'm spending minute one on the actual problem. A website redesign, an automation, a tricky bit of IT cleanup, a new internal process — all of it moves faster because the re-explanation tax is gone, and every session starts further ahead than the last one did.

The loop that feeds itself

Here's the thing I underestimated, and the part I'd now put at the center when explaining ThoughtOS to anyone else: it isn't capture-and-store. It's a loop that gets sharper every time I use it. Every meeting I sit in, every email I read, every Teams message I reference, every document I scan — if it matters, a distilled version can go in. But it all passes through me first.

I'm the filter. I decide what's signal and what's noise, what's a decision worth keeping and what's just conversation, which fact or relationship or pattern will actually help future work. That's what keeps the system useful: it doesn't hoover up everything indiscriminately and drown in its own intake — it remembers what I, the human in the loop, judge worth keeping. Every iteration teaches it a little more of the shape of my world.

Because I'm the curator, the signal stays high, and the system gets more useful the more I work with it instead of noisier. The loop feeds itself — but I'm the one who decides what it's fed.

It doesn't die with my laptop

One thing I didn't appreciate until I felt it: I've stopped worrying about losing any of this. If Claude goes down, if my PC dies tomorrow, if I switch machines — the second brain doesn't go with it. It lives independently of any one app or device. Hand a fresh session the memory and I'm back up to speed in minutes, with almost no lost context.

And it isn't chained to a single AI, either. The same memory can be read by other assistants, so I'm not betting my entire working context on one company's product staying available, useful, or best-in-class. That portability quietly removed a fear I didn't even know I was carrying: that the most valuable thing I'd built was also the most fragile.

The part nobody puts in the pitch

ThoughtOS isn't magic, and it isn't free. A memory layer is a garden, not a filing cabinet. But here's the thing — before ThoughtOS, I wasn't gardening. I was searching: hunting for notes, reloading context, trying to remember which loose thread belonged where. That's not tending a garden; that's running around looking for your tools.

Right now I'm sitting on a few hundred memories and a health score in the high fifties — which sounds mediocre until you realize the number is telling me something true: some of what I captured early is aging, some should be retired, some needs correcting or merging. That feedback is part of the value. The captures are easy; the discipline of occasionally pruning, fixing a wrong fact, and merging duplicates is what keeps the whole thing trustworthy.

What it really bought me

If I had to put it in one line: I re-explain myself far less, and the things I make now build on each other instead of starting from scratch. The wins are rarely dramatic on their own — a cleaner recap here, a connection caught there, a faster build because the context was already loaded, a meeting where I actually stay present because I trust the right thing will surface when I need it. But six months in, the compounding is real.

The bottleneck was never that I lacked information. It's that the information lived mostly in me, and I'm a single-threaded, easily distracted, human-shaped bottleneck. That's the pattern I keep coming back to in the lab: most bottlenecks aren't knowledge problems, they're access problems. The fix usually isn't more information — it's putting what you already know somewhere it can actually be used, so you're free to do the work in front of you.