The Shared Brain

Andrej Karpathy just described something we've been running in production since the beginning of the year. He's calling it a personal LLM wiki. We've been calling it the Shared Brain. The personal version is a great idea. It's also only half the idea.

His pattern: ingest raw sources into a directory, have an LLM compile them into a structured markdown wiki, query against the compiled knowledge, and file your explorations back into the wiki so they compound over time. You rarely touch the files directly. The LLM does the bookkeeping. The knowledge gets denser with every query. He even published a gist with the concept abstracted enough for any agent to build a customized version for you -- the idea as the interface, not the code.

He's right that this is genuinely useful. 

What he's describing is a single-player game that maximizes that player’s advantage. We built the multiplayer version.

The shared brain we run, like Karpathy’s, is a git-backed vault of markdown files maintained by LLM agents across a team. One repository. Every piece of content lives there: tasks, ideas, competitive intelligence, product specs, strategic objectives, content pipelines, people profiles, and accumulated agent memory. All of it interconnected via a graph of markdown. Agents do the writing and maintenance. Humans curate sources, make decisions, and ask questions.

You can open the vault in Obsidian and navigate it as a living knowledge graph. Or you can talk to a CLI agent in plain language and get answers drawn from the full vault. Or you can use a desktop agent that renders everything as an interactive dashboard and handles more complex queries. Multiple interfaces, same underlying knowledge. The agents decide what's relevant to surface based on the context, it’s not the user deciding what folder to open.

The CLI interaction is worth describing in detail because it's where the behavior diverges most sharply from a traditional wiki. You don't navigate. You ask. "What am I working on right now?" gets you a contextual summary calibrated to you specifically: what's due, what's stale, what's blocking something else, what aligns to the team's current objectives. "Add a task for the FlySight presentation" gets you attribution, suggested tags, and surfaced relationships to other vault items you didn't know were connected. "Wrap up" at the end of a session captures what was decided, what's still open, and what the next session should pick up -- and writes all of it back to the vault so nothing disappears into chat history.

The memory system is what makes this categorically different from a wiki.

The vault accumulates two kinds of memory. Per-user memory: working patterns, focus areas, preferences, things you've told the agent over time. Not notes you write about yourself. Notes the agent writes about you based on observation. It's what allows the system to say "the FlySight presentation is your most urgent thing and you have four days" instead of "here are your 25 tasks sorted by date added." The agent reasons about effective priority using due dates, strategic objective impact, dependencies, your recent attention patterns, and item staleness. Static priority labels are one signal. They're not the answer.

Team-level memory captures decisions and operating context that persist across all users and all sessions. When the operating report reflects a revenue gap, every user's summary reflects that risk -- without anyone having to forward the report or update a dashboard. When someone works through a pricing rationale, that reasoning gets captured and informs the next pricing conversation, even if the person who worked it out isn't in the room.

Knowledge compounds differently at team scale than it does for a single user. When one team member adds competitive intelligence, the agent doesn't just append it to a file. It checks for contradictions against existing knowledge, cascades implications to related tasks and ideas, builds bidirectional cross-references across the vault, and updates the master index. One addition can update three tasks, cross-reference two existing notes, and flag a contradiction with outdated positioning -- in a single operation. The vault gets denser and more interconnected with every contribution, from every person.

This is the core value proposition that the single-player version can't replicate. A product manager investigates a competitive threat and the intelligence surfaces automatically when a sales person asks for deal context. An engineer documents a system constraint and it appears during spec writing without anyone sending a Slack message. The knowledge doesn't just compound for one person. It compounds for everyone, from every direction, continuously.

The problem this creates at team scale is one Karpathy doesn't have to solve: whose version of reality wins.

Two people describe the same customer differently. Three documents make contradictory claims about a product capability. Someone's competitive intel is six months stale and contaminating fresh analysis. These aren't edge cases. They're the normal state of any team's distributed knowledge. Traditional wikis handle this by relying on humans to notice and fix inconsistencies, which means they mostly don't get fixed.

We run automated health checks across seven categories: contradictions, stale claims, orphan pages, missing pages, missing cross-references, coverage gaps, and basic hygiene. Auto-fixable items get fixed automatically. Issues that require judgment get surfaced for a human. The first full run found 23 issues across 14 files. That is not work any team of humans would voluntarily do on a regular cadence. The LLM doesn't mind doing it every week.

We're also adding a knowledge graph layer so semantic search works even when items don't share explicit tags -- finding related items by meaning rather than by label. The vault today is already a graph in structure. The graph layer makes that navigable programmatically, which opens up relationship discovery that tag-based search misses entirely.

Karpathy's framing of the idea file is the most interesting part of his post. Share the idea, not the code. Let someone else's agent build a version customized to their specific needs. That philosophy is exactly how we think about what we've built. The vault is the idea made operational -- persistent across the whole team, continuously maintained by agents, queryable at any moment by any agent that needs context.

He's right that there's an incredible product here. We're not waiting for it to be built.

The single-player version is a productivity tool. The multiplayer version is an organizational nervous system.