I build brains within brains. Twenty knowledge bases, auto-generated web portals, write-time AI compilation, and a hybrid architecture that the AI community is just now discovering they need.
In early 2026, Andrej Karpathy — former head of AI at Tesla, founding member of OpenAI, one of the most respected researchers in the field — proposed a simple idea: use an LLM to build and maintain a personal wiki from your files.
Over 100,000 people bookmarked it. The idea went viral because it changes how AI relates to your knowledge over time. Instead of asking the AI to re-derive every answer from scratch, you let it compile your knowledge at write-time. The AI's understanding is persisted, updated, cross-referenced — not forgotten the moment the chat window closes.
When I saw it, my reaction was: I've been running this for months.
Not a wiki. Not a single knowledge base. Twenty of them. With structured evidence scoring, automated web portal generation, one-command deployment, AI agent access via MCP, and a hybrid architecture that independently arrived at the exact same design the analysis community is now describing as "the mature system."
I call them "brains." Each one is a structured JSON knowledge base focused on a single domain. Every entry has metadata: source, evidence tier, category, tags, claims, practical actions. The AI does the hard thinking at ingest time — extracting, categorizing, deduplicating, scoring — not every time I ask a question.
Here are the 20 brains running right now:
That's not a list of topics I'm interested in. That's a compound knowledge engine where every new piece of information is scored, categorized, cross-referenced, and permanently available to any AI conversation I have.
The analysis community has identified the core architectural choice that separates knowledge systems: when does the AI do the hard thinking?
Karpathy's approach (write-time): The AI ingests new sources, extracts what matters, writes and updates wiki pages, cross-references, flags contradictions. The heavy work happens on ingest. Queries are cheap because the syntheses already exist.
A raw database approach (query-time): Store inputs faithfully with metadata. The AI thinks when asked, synthesizing from stored entries on the fly. Ingest is cheap, but deep queries are expensive and you re-derive the same synthesis every time.
My system does both. And that's exactly what the latest analysis concludes is the mature architecture.
Each brain is a JSON file with a strict schema. The anti-aging brain, for example, scores every entry with:
This is the authoritative store. AI tools query it. Humans don't read raw JSON.
When new information enters the system — from YouTube summaries, research papers, PDFs, conversations — an AI ingest process runs at write time:
This means the thinking is done once, at ingest. Every future conversation that touches this knowledge starts from a pre-compiled, scored, categorized foundation — not from raw text.
Five of the brains auto-generate public web knowledge bases:
One command: python sync-brain-web.py climate — and it regenerates the web KB from the JSON source, copies to the deployment folder, and FTP uploads. The generated HTML is never edited directly. Change the brain, regenerate, redeploy.
The brains are exposed to AI conversations through MCP (Model Context Protocol) tools. Any AI session can:
This means the AI doesn't start from zero in each conversation. It starts from 2,000+ pre-compiled, scored, categorized knowledge entries.
The obvious objection: "Why bother compiling? Just dump everything into the context window. Gemini can handle 2 million tokens."
Bigger context windows let AIs see more raw data. But seeing isn't the same as having already thought through relationships, tradeoffs, editorial weightings, or curated narratives.
When my anti-aging brain has 169 entries with evidence tiers, the AI doesn't need to re-evaluate whether resveratrol works every time someone asks. That judgment is compiled: debunked (Semba 2014, JAMA Internal Medicine, null across all endpoints; GSK $720M write-off). The AI reads the pre-compiled verdict and builds from there.
Without pre-compilation, every conversation re-derives the same syntheses, makes the same editorial calls, and risks different conclusions from the same data depending on prompt phrasing and model mood. Pre-compilation creates institutional memory — the same judgment, applied consistently, improving over time.
| Dimension | Karpathy Wiki | My Hybrid System |
|---|---|---|
| Solo researcher, deep topic | Excellent | Excellent |
| Scale (100s of entries) | Fine | Fine |
| Scale (1,000+ entries) | Struggles | Built for this |
| Multiple domains/brains | Not designed for it | 20 brains, each focused |
| Evidence scoring | No schema | Per-entry tiers |
| AI agent access | File-based RAG | MCP tools, structured queries |
| Auto-generated web portals | Manual | One-command regen + deploy |
| Human browsability | Wiki format | Generated HTML + JSON download |
| Provenance tracking | In prose | Structured source fields |
| Contradiction detection | Manual | conflicts_with arrays (manual) |
| Offline use | Text files | JSON files |
| Setup complexity | Low | High (built over months) |
Karpathy's approach is elegant for a solo researcher working on a single topic. It's a wiki — write freely, let the AI edit and cross-link. Simple, human-readable, works with text files.
It cracks at scale, at multi-domain, and at automation. A wiki that "smooths over" contradictions may hide the critical signal. Well-written but stale syntheses can mislead more than obvious gaps in a database. And when you have 20 domains with different evidence standards, a single flat wiki can't enforce the rigor that each domain requires.
Both approaches share a conviction that most people haven't internalized yet: AI should be a maintainer, not an oracle.
Most people use AI for one-off answers. Ask a question, get an answer, close the window. That's like hiring a brilliant employee and firing them every evening. The knowledge they built during the day? Gone.
A knowledge base system treats the AI as a continuous worker. It ingests, scores, categorizes, cross-references, flags contradictions, generates reports — and all of that work persists. Tomorrow's conversation starts where today's left off.
I didn't plan to build a system that anticipated Karpathy's proposal. I built it because I needed it. Twenty topics. Thousands of entries. Multiple products and projects drawing from the same knowledge pools. A single brain wasn't enough. A chat window that forgets everything wasn't enough. I needed brains within brains — and the infrastructure to make them compound.
The system works. Here's where it goes from here:
The goal isn't to build the biggest knowledge base. It's to build the one that thinks the most clearly — where every entry is scored, every contradiction is surfaced, and every conversation I have with AI starts from a foundation of compiled, trustworthy, structured knowledge.
You don't need 20 brains to start. You need one. Pick a topic you know deeply. Create a JSON file with a schema that captures what matters. Start ingesting. Let the AI do the grunt work of extraction and formatting. Keep editorial judgment — what to include, how to score it, what contradicts what — in your hands.
The tools are available. Karpathy published his gist. I've been using Claude Code as my primary development environment. The architecture isn't proprietary — it's a design pattern. Structured data in, compiled knowledge out, generated portals on top.
The hard part isn't the technology. It's the discipline to build incrementally, score honestly, and resist the temptation to let the AI's editorial judgment replace your own.
Your brain is the curation layer. The AI is the compiler. The knowledge base is the artifact that survives between conversations.
Start building.