I built a knowledge system. It started thinking for itself.
"Should I open source one of my projects?" — That's what I asked my vault.
A strategy question. I expected positioning analysis, competitive risks, community dynamics. The vault gave me all of that. Solid breakdown. Fourteen points across pros and cons, grounded in my own past thinking.
Then it went somewhere I didn't expect.
It cross-referenced the question against six months of my own notes. Journal entries, voice memos, project retrospectives, raw iPhone dumps, even past conversations with Claude I'd forgotten I'd had. And it named something I hadn't named myself.
My pattern of building to 85% and hesitating at the commitment threshold. The gap between my stated goals and my actual shipping behaviour. A specific tendency to generate new project ideas right when I'm close to finishing one. It quoted a line from my own notes back to me: "FOMO wearing a business plan costume."
The strategic analysis was useful. The self-awareness was something else entirely.
That's not a filing cabinet.
I've been building knowledge systems for two years, across four AI products. That was the first time one of them knew me.
What most setups don't do
There's a wave happening right now. Multiple major posts about Claude + Obsidian in the past few weeks. Massive reach. Tens of thousands of bookmarks. Good energy. Real value. The stack works.
But the posts occupy different levels.
The biggest ones are plumbing: connect Claude to your vault, set up the pipes. Hundreds of thousands of views on the best guides.
Next level is architecture. Skill graphs with wikilinks and YAML frontmatter. Progressive disclosure. Interconnected file networks. Genuinely elegant.
Someone in the wave called the methodology layer "unbuilt." Storage and retrieval are commoditizing. The real moat, he said, is "rules for what connects to what." He was right.
Past tense.
Every setup in the wave describes a library. Some are beautiful libraries. Graph-connected, traversable, well-structured. They answer questions you know to ask. They surface files you remember exist. They organize what you put in front of them.
But every note you add creates a small cognitive tax.
Where does this go? Does it duplicate something? Should it be a skill, a context file, a project note, or just a thought? That tax compounds. Within weeks, you're spending more time filing than thinking. You built a beautiful structure and became its maintenance crew.
Perfect architecture. No intelligence. The library is gorgeous. But the librarian is you.
And you have other things to do.
The difference between a library and a librarian is judgment.
How it works
Two levels of permeability.
First level: wide open. Voice memos, iPhone notes, half-finished thoughts, conversation transcripts, repos, articles. Everything hits the inbox. Zero friction. No "where does this go?" at the point of capture.
Second level: titanium. An autonomous filter governs what enters the vault. It applies a worthiness rubric to every inbox entry: does it apply across multiple projects? Would the AI get this right without it? Is the pattern stable enough to encode? Does it shift default behavior? If not, it stays in the inbox or gets discarded.
No human in that loop.
I designed the rubric. The system applies it. That's the difference between setting standards and doing the filing.
Three processes handle everything between capture and vault: ingestion, abstraction, compression.
I found an interesting repo last week about agent memory architectures. Instead of bookmarking it and forgetting (which is what actually happens), the system ingested it: what it does, how it works, which of my projects connect to it. Three days later an agent session surfaced it unprompted while planning a related feature.
A note from a startup postmortem about running "pre-mortems" before launch, where the team assumes the project already failed and works backward to find why, got abstracted into: "simulate failure before you invest in execution." That principle now sits next to my agent orchestration notes. It's why one agent's only job is to attack the plan before anyone starts building.
A 40-minute client call about market positioning got compressed into six actionable insights, two doctrine-level observations, and a flag that one of the client's assumptions contradicted something in my own research from two months ago.
The raw transcript evaporated. The intelligence persisted.
The vault grows without you filing anything. But growth isn't the point.
What happens when it compounds
I ran a new product spec through the vault last week.
A paid media agent I was scoping for a client. Completely different domain from my existing projects. The vault read the spec and came back with something I hadn't asked for: three modules from my agent orchestration system that were directly portable. The scheduling engine, the feedback capture pipeline, and the queue prioritization logic. Not similar concepts.
Directly reusable components.
Two products that looked unrelated turned out to share 40% of their architecture. That's a week of design work I didn't have to do. And a product that launched with stronger foundations than I'd have built from scratch, because the shared modules had already been battle-tested across dozens of runs.
I didn't see that. The vault did.
A different week: 200 lines of raw iPhone notes dumped into the inbox. Unformatted. Stream of consciousness. The system sorted all of them. Most got discarded as noise. A few got routed to content slots with specific angles attached. One got promoted to a doctrine candidate, a principle worth encoding permanently.
Then it did something I didn't ask for. It noticed that three of the discarded notes, from different days and different contexts, were circling the same unresolved question. It grouped them, named the pattern, and flagged it as recurring but uncrystallized.
The vault noticed I was thinking about something before I noticed I was thinking about it.
The bigger picture
I didn't build this as a product. But I've started noticing something about what it changes.
This isn't just knowledge management. It's context infrastructure.
Every AI session starts cold. The model is powerful. The context window is empty. You spend the first 20% of every interaction reconstructing what you already knew. That's not a model problem. That's a memory architecture problem.
The vault solves it at the human layer. Every session I start comes pre-loaded with project context, accumulated doctrine, and lessons from previous runs.
The AI doesn't guess. It knows.
At the agent layer, the same pattern applies. My agents carry structured memory files that compound with every run. The agent that executed 50 sessions makes fewer mistakes, catches more edge cases, and produces output that sounds like me instead of default Claude.
Same model. Different intelligence.
Human knowledge compounding in the vault. Agent knowledge compounding in the pipeline. Both feeding each other.
If that pattern ports to teams, to organizations, to client deployments where each engagement builds on everything that came before... that stops being a personal productivity system. That's persistent intelligence infrastructure.
I'm not there yet. But the direction is visible.
And sometimes the vault shows me what it looks like when it works.
The part I'm still processing
Last month the vault connected a Portuguese economics article to my pricing model and insect colony behavior to my agent orchestration. I didn't search for either.
That's not search. That's the system finding what you didn't know to look for.
Most setups are libraries. Good ones. Well-organized, traversable, useful.
Mine is closer to a librarian. One that reads everything, decides what matters, files it without being asked, and occasionally surfaces something that changes how I think about a problem I didn't know I had.
The structure is the easy part. The intelligence is what compounds. I'm not sure where that leads. But I don't think I'm building toward it alone.