# We built the AI second brain. The agents never opened it.

2026-10-21 . Mike Boscia . https://e5bravo.com/hnt/second-brain/

My feed is full of AI second brains right now, and the pitch is the same every time: folders of notes, a wiki the AI keeps tidy, a rules file the agent reads at the start of every session, and your AI remembers everything and gets smarter every day you use it.

So I went through every one I'd saved, which came to about two dozen builds that people described as their own, and fourteen of them were written up in enough detail that I could actually take them apart.

Then I did the same thing to ours.

This is a Found post, so the shape is: what other people are building, and what happened when we measured the same thing on our side.

## What they built

The ones that travel are simple, and I don't mean that as a knock. The most-shared build in the set, an article its author says passed 8 million views, is an Obsidian vault, a rules file the agent loads every session, and one plugin that lets the agent read the vault. Twelve of the twenty builds are some version of that: folders, a rules file, maybe one tool.

Simple is fine. Simple is how you start.

Four of the fourteen I could read in full are serious engineering, and I mean that too: access tracking, a governed write path with an audit trail, million-document ingest pipelines, company-scale memory with permissions.

Here's the thing, and this is what surprised me. The serious builders put almost all of their rigor on the way in, what gets stored, how it's cleaned, who's allowed to write, what wins when two notes disagree, and almost nobody instruments the way out.

So of the fourteen, one counted whether the agent actually opened its own files, and none tested whether the AI did better because of it. A couple claimed time saved. Nobody showed a before and after. The most-shared one says it "gets sharper every single day you use it," and that's the whole evidence.

Now, the vendors selling memory do publish scores, on lab test sets, and that's real work, because it tells you the right fact comes back when a test asks for it. What it doesn't tell you is whether your agent, in the middle of your work, ever asked.

## The one who measured

Jacob Dietle builds context-os, a knowledge graph for Claude Code, and he did the thing almost nobody does, which is track which files the agents actually opened.

"In practice, agents never read those files."

His taxonomy file: "2 accesses in 90 days." The ontology file: 1. The lifecycle doc: zero.

So he rebuilt the whole system around that number, and his line for it is the one I keep coming back to: "If a file has zero heat, it's the concrete path nobody walks."

Eric Siu measured a different thing at Single Grain, and it's the one nobody else in the pile counts, which is what memory costs. "Our persistent memory files started eating about 40% of the context window. Agents had more information, but they weren't always pulling the right information at the right time."

Two builders checked. Both of them ended up rebuilding.

## What we built

Ours is on the heavy end.

Every working session feeds a memory graph: lessons, decisions, corrections, the things I'd otherwise have to explain again. A compiler turns that graph into wiki pages, one per subject, and every claim on a page carries the verbatim quote it came from and the id of the note it came from.

A map of the whole wiki, one line per page, goes into every agent's prompt. Every session, every project. It tells the agent what's there, and it tells the agent to open the page before acting on its subject.

And because I've been burned by this exact kind of thing before, we built a nightly scan that counts page opens.

## The scan said zero

The map went live on September 19. Three days later:

12 sessions had the map in the prompt.
Sessions that opened a page: 0.
Page reads: 0.
Searches of the wiki: 0.

The 152 sessions from before the map existed are the control, and their page reads are also 0. So the map was doing exactly as much as no map.

New Achievement!

**Required Reading**

You have placed a 20 page wiki in front of every agent you run. It has been opened 0 times. The table of contents has been loaded in full, every session, for everyone.

Reward: a very well informed agent that knows exactly which pages it isn't going to open.

## The memory underneath

The wiki compiles from the memory graph, so once the wiki came back zero I counted the graph too.

31,937 facts stored. A hook pulls the ones that look relevant and puts them in front of the agent on every prompt, and we added a counter for whether the agent used any of them.

267 facts handed to the agent. 4 used. 1.5%.

And the search itself worked, which is the part that took me a minute. When the agent asked the memory a question on its own, it used what came back in 56% of those turns, and when the hook pushed facts in unasked, 6.5%, same store, same ranking. So the machine finds things fine. The hook just never asked it anything.

Most of what got pushed shouldn't have been stored in the first place. A random 400 facts, judged one by one: 28% worth keeping. The write gate had approved everything above its confidence threshold for four months, zero rejections, and zero rejections got read as a healthy pipeline. That's on me.

That's Siu's 40% from the other direction. Memory isn't free, because every fact you inject is context the agent spends on your notes instead of your work.

## Nothing looked broken

The status line counted injections. "Facts served to this prompt." And injections look like use, so every session showed memory working.

The scan worked too. It found the zero on its first run, wrote the zero to a reports folder nobody tracked, and nothing pushed it anywhere I'd see it.

I found out because I asked.

## What changed

When I actually looked at the map the agents were getting, one problem was sitting in plain sight: it told every agent to open the page, and the links were bare filenames with no folder, so from any other project on the machine there was nothing to open.

The second problem is subtler. A map read once at the top of a session is background. By the time the agent is about to touch DNS or a deploy, nothing about that moment says "you have notes on this."

So, two fixes on October 11. The links became full paths. And a gate now sits at the moment of acting: the first time a session goes to touch a subject the wiki covers (a DNS record, a deploy, an Instantly campaign), the action is held once and the agent is pointed at the page. Reading it clears the gate. Going ahead anyway is allowed, and logged.

Before those fixes, of the first 104 sessions with the map, 6 had opened a page.

This morning's scan: 139 sessions, 48 opened a page, 111 page reads. The control is still 0.

## What we still don't know

Here's the uncomfortable part. 48 of 139 is use. It isn't impact.

We know the agent opens the page now. What we don't know yet is whether it makes fewer of the mistakes the page was written to prevent, and none of the fourteen showed that either, and that includes us.

So that's next. The measure we're designing is corrections I make on things the wiki already knew, because if the wiki works, that number goes down, and it goes down compared with sessions that run without it. We'll publish what it says, including if it says the wiki doesn't help.

## When injection is enough

Concession, because there is one. If your second brain is small enough to fit in the prompt whole, put it there and stop worrying, because there's nothing to open. A personal vault of a few hundred notes may well be there.

And if you read every output yourself, you're the counter. You'll notice when the agent ignores what it was given.

The trouble starts when the brain outgrows the prompt and becomes a menu, because a menu is only useful if someone orders from it, and nothing about a menu tells you when nobody does.

## Check yours

If you built one, three questions.

1. When did an agent last open a page in it? Not "when was it in the prompt." When did one actually read it, and how would you know?
2. What does it cost? How much of every prompt goes to memory before the work starts?
3. What got better? Name one mistake it stopped. If you can't, you don't know yet whether it works.

Then count reads, not injections, and make zero a red light.

Building the brain is the easy half.
