Build a Personal AI Brain That Actually Helps

Most "personal AI brain" advice is still note-taking advice with a chatbot bolted on.

Save everything. Tag everything. Ask questions later.

That is not enough.

The better model is closer to Andrej Karpathy's LLM Wiki pattern: build a personal knowledge base where the LLM does the boring maintenance work. You bring sources and judgment. The model turns those sources into a structured, linked, durable wiki.

The key shift is simple:

Do not use AI only to retrieve old notes. Use AI to maintain a living map of what you know.

The problem with most AI brains

Most AI knowledge systems are just retrieval systems.

You upload notes, docs, transcripts, PDFs, bookmarks, and meeting recaps. Later, the model searches chunks and tries to answer from whatever it finds.

That works for simple questions:

• What did I say in that meeting?
• Where is the PDF?
• Summarize these notes.

It breaks down when the question requires synthesis:

• What has changed in my thinking over the last three months?
• Which ideas keep showing up across meetings, books, and projects?
• Where do my notes contradict each other?
• What should I believe now, after everything I have read?

Retrieval makes the model rediscover the same context every time. A living wiki compiles the context once, then keeps improving it.

The model: raw sources, wiki, schema

The clean version has three layers.

personal-brain/
  raw/
    articles/
    transcripts/
    books/
    meeting-notes/
  wiki/
    index.md
    entities/
    concepts/
    projects/
    sources/
    synthesis/
  log.md
  AGENTS.md

1. Raw sources

Raw sources are the things you collect.

They can be articles, podcast notes, meeting transcripts, Kindle highlights, PDFs, Slack threads, voice memos, or your own messy thoughts.

The rule: raw sources are immutable. Do not let the agent rewrite them. They are evidence.

2. The wiki

The wiki is the model-maintained layer.

This is where the LLM writes summaries, concept pages, entity pages, project pages, comparison notes, and synthesis pages.

You read the wiki. The LLM maintains it.

That distinction matters. Humans are bad at keeping wikis alive. We forget to update links, merge duplicate ideas, and revise old pages when new information arrives. LLMs are good at that kind of bookkeeping.

3. The schema

The schema is the instruction file.

In Claude Code, it might be CLAUDE.md. In Codex, it might be AGENTS.md. The name matters less than the job.

The schema tells the model:

• where raw sources live
• where wiki pages live
• what page types exist
• what frontmatter fields to use
• how to ingest a source
• how to answer a query
• when to update related pages
• how to log changes
• what the model is never allowed to overwrite

Without this file, you have a chatbot with a folder. With it, you have an operator that understands the system.

The three operations

A useful personal AI brain needs three repeatable operations: ingest, query, and lint.

Ingest

Ingest is what happens when you add a new source.

Bad ingest:

Summarize this article and save it somewhere.

Good ingest:

Read this source. Create a source summary. Update the relevant concept pages, entity pages, and project pages. Add any contradictions or new open questions. Update index.md. Append an entry to log.md.

One good source may touch ten wiki pages.

That is the point.

If you read a great article about AI agents, the system should not only create sources/article-name.md. It should update your pages on agents, workflows, tooling, business applications, and any active project that depends on that idea.

That is how knowledge compounds.

Query

Query is how you ask the brain questions.

The model should not search the entire vault blindly. It should start with wiki/index.md, identify the most relevant pages, read those, then answer with source paths.

Good questions look like:

What are the strongest ideas I have collected about AI-native businesses?
Use the wiki first. Cite the pages you used. If the answer creates a new useful synthesis, suggest a new wiki page.

The important move: good answers should not disappear into chat history.

If a query produces a useful comparison, decision, framework, or synthesis, file it back into the wiki.

Lint

Lint is the health check.

Once a week, or whenever the system feels stale, ask the agent to inspect the wiki.

It should look for:

• orphan pages
• stale claims
• broken links
• duplicate concepts
• missing concept pages
• contradictions between pages
• raw sources that were never integrated
• important questions that keep appearing but have no home

This is the part that makes the system stay useful instead of becoming another abandoned notes folder.

Start small

Do not build a giant operating system on day one.

Start with this:

raw/
  inbox/
wiki/
  index.md
  concepts/
  sources/
  synthesis/
log.md
AGENTS.md

Then add one source at a time.

For the first ten sources, stay involved. Read the summary. Check what pages the model updated. Tell it what it missed. Fix the schema.

You are not only building the wiki. You are training the maintenance process.

What belongs in the raw folder

Good raw sources have enough signal that future-you would want them.

Start with:

• your best meeting transcripts
• articles you keep thinking about
• book notes and highlights
• project retrospectives
• strategy docs
• voice memos with actual insight
• customer conversations
• decisions and why they were made

Avoid dumping everything in.

More context is not always better. A personal AI brain gets better from high-quality sources and clear maintenance rules, not from indiscriminate hoarding.

What the AI should write

The wiki layer should not be a pile of summaries.

It should contain pages like:

• concepts/llm-wiki.md
• concepts/agentic-workflows.md
• concepts/personal-operating-system.md
• projects/personal-site.md
• synthesis/what-i-believe-about-ai-and-work.md
• sources/karpathy-llm-wiki.md

Each page should have a job.

Concept pages explain ideas and link to sources.

Entity pages track people, companies, tools, and products.

Project pages preserve goals, constraints, decisions, and next actions.

Synthesis pages turn many sources into a point of view.

That last category is where the real value is. A personal AI brain should help you develop taste, judgment, and memory. It should not only help you find files.

A starter AGENTS.md

Use something like this as the first instruction file:

# Personal AI Brain Rules

## Folders

- raw/ contains immutable source material. Never edit raw files.
- wiki/ contains LLM-maintained markdown pages.
- wiki/index.md is the first file to read before answering questions.
- log.md is append-only.

## Ingest

When ingesting a source:
1. Create a source summary in wiki/sources/.
2. Update every relevant concept, project, entity, or synthesis page.
3. Add contradictions, open questions, and new links.
4. Update wiki/index.md.
5. Append a timestamped entry to log.md.

## Query

When answering:
1. Read wiki/index.md first.
2. Read the 3 to 7 most relevant pages.
3. Answer with citations to wiki pages and source summaries.
4. If the answer is durable, propose a new synthesis page.

## Lint

When linting:
1. Find orphan pages.
2. Find stale claims.
3. Find duplicate concepts.
4. Find broken links.
5. Find unanswered recurring questions.
6. Propose fixes before making large structural changes.

This is not perfect. It is a starting point.

The right schema emerges by using the system.

What this looks like in practice

Imagine you read Karpathy's LLM Wiki gist.

A weak system saves the link.

A better system creates:

• a source summary for the gist
• a concept page for LLM-maintained wikis
• updates to your AI tools page
• updates to your knowledge management page
• a synthesis page on why RAG is not enough for personal knowledge
• open questions about search, source quality, and maintenance
• a log entry recording the ingest

Now the next time you ask, "How should I structure my personal knowledge base?", the system does not start from zero. It already has the synthesis.

That is the difference between storage and a brain.

The human role

The LLM should do the maintenance.

You should still do the thinking.

Your job is to:

• choose better sources
• ask sharper questions
• reject weak summaries
• correct bad links
• decide which synthesis matters
• turn the output into action

Do not outsource your judgment. Outsource the bookkeeping that keeps your judgment available.

The rule

A personal AI brain is working when your ideas compound.

Not when your folder tree looks impressive.

Not when every note is tagged.

Not when you have the fanciest app.

It is working when a source you added last month quietly improves an answer today. It is working when the model remembers the context you would have forgotten. It is working when old notes become usable because the wiki has already connected them.

Build that.