Everyone builds local-first second brains. I'm building the opposite.

The most sacred rule in personal knowledge tools is local-first. Your notes as plain files, on your disk, readable without any app, outliving every company that ever touched them. Ink & Switch canonized it in their 2019 essay (“you own your data, in spite of the cloud”)¹ and Obsidian turned it into a design philosophy its CEO summarized as “file over app.”² It is a good principle, argued by people I take seriously.

I’m building the opposite, on purpose. LoomBrain is a second brain that deliberately does not live on my machine. This is the build log and the argument, including how the local version I built with my own hands is what convinced me local was wrong.

The reader changed

Local-first optimizes for a specific reader: a human, at a keyboard, opening their own notes. For that reader, disk locality is strictly good: fast, private, permanent.

But look at who actually reads my notes now. Claude Code, mid-task, checking what I decided last month. A weekly-review agent compiling what happened. A capture agent filing a page I clipped from my phone. The reader is increasingly software acting on my behalf. And software doesn’t sit at my keyboard. My computer sleeps, gets shut, stays home. My agents don’t sleep at all.

So the design follows one sentence: the brain has to live where the agents live, on the network. LoomBrain runs on Cloudflare’s edge; Claude Code, Claude Desktop, ChatGPT, whatever I’m working in, reaches it from any machine at any hour over MCP³ or a CLI. The data is deliberately not on my machine, because “my machine” stopped being where my work happens.

To be fair to the sacred cow: local-first was never about disks. It was about ownership: a defense against apps holding notes hostage. I keep the ownership goal entirely: export anytime, an open schema, my own tenancy. I just reject the conclusion that ownership requires locality. Your email has lived on the network for twenty years; you own it fine. What local-first got right, agent-first keeps. What it got wrong is assuming the only reader who matters is you.

Build log: three rebuilds in four months

v1 was an MCP-primitives prototype: the brain as a set of tools and nothing else. No interface, no opinions, just storage and retrieval exposed over the protocol. It proved the connection model instantly: any MCP client could be a client of my memory. It also proved that primitives alone aren’t a brain. Give an agent raw store and search and it uses them the way a toddler uses a filing cabinet. A brain needs opinions: structure, hygiene, a model of why things connect.

v2 was a deliberate step back: fully local, built as Claude Code skills, everything running on my machine with a top model doing the thinking. This version found the workflows that earn daily use: capture-with-reason, weekly review, project context that loads when I start a session. And it demonstrated its own ceiling by working: the better it got, the more it hurt that it existed only where I sat. No capture from my phone. Nothing running while I was away. A second computer meant a second, diverging brain. The local version is what radicalized me. The argument for the network wasn’t theoretical; it was every evening the brain went dark because I closed a lid.

v3 is loombrain.com: the cloud rebuild. TypeScript on Cloudflare Workers, D1 for the graph, Vectorize for retrieval, and autonomous agents as Durable Objects: graph hygiene, weekly review, a daily digest, all running on the edge whether or not any machine of mine is awake. Around it, the full surface: Chrome extension, dashboard, CLI, MCP server. Multi-tenant from day one, because a brain for one is a prototype pretending otherwise.

The other opinion: capture the why, not just the what

The second contrarian bet is smaller but I might believe it harder. Every capture in LoomBrain records why you saved it.

Content alone mis-files things. A bookmarked article about SQLite could plausibly belong to five projects; a screenshot of a pricing page could be competitor research or a design reference or a receipt. Any system that classifies by content is guessing among the plausible. But the stated intent (“saving this for the newadmin migration,” “this contradicts my caching decision”) collapses the ambiguity to zero. The why is what lets the model connect the node to the right place in the graph, and right connections are the whole game: retrieval quality is decided at capture time, not query time. The PARA structure on top⁴ gives the graph its spine, but the why-annotation is what makes it load-bearing instead of a pile of tagged bookmarks.

Retrieval quality is decided at capture time, not query time.

Status, honestly

LoomBrain is launched, public, multi-tenant, and free: free because I pay all the costs, and I pay all the costs because almost nobody uses it. I use it every day; it is my daily tool and my exploration project, not as good as it should be, better every week. I know exactly where the ceiling is: D1 and Vectorize have hard platform limits⁵ that a real user base would meet. The plan is unglamorous and sequenced: make the product good, migrate to Postgres and pgvector, then invite people. Step by step. Growth before that order would just scale the mediocrity.

I could dress that up as strategy, but the truth is simpler: this is what exploring in public looks like when you refuse to fake traction.

The conviction, though, is not humble at all. Ask where the puck is going: every tool you use is growing agents, every agent needs memory, and no agent worth having can read a markdown vault on a laptop that’s asleep in another city. In five years, “where are your notes stored” will sound like “where is your email stored”, a question nobody asks anymore. Everyone is building second brains for people to read. I’m building one for the workforce that never sleeps.