LLMWiki is a pattern, not a product. Andrej Karpathy described it in late April 2026 as a workflow where raw sources (notes, docs, agent sessions, transcripts) go into a folder, and an LLM continuously maintains a structured Markdown wiki summarizing them. Future agent sessions read that wiki instead of rediscovering context every time. The pattern reframes LLMs from chat interfaces into compilers of persistent knowledge.

Is LLMWiki a product I can install?

Not officially — it's a pattern. But several open-source implementations launched within days of Karpathy's gist. Pratiyush/llm-wiki turns Claude Code, Codex CLI, Copilot, Cursor, and Gemini CLI sessions into a wiki. Lucasastorian/llmwiki is a hosted-style implementation that connects via MCP. tjiahen/awesome-llm-wiki is a curated list of all current implementations. Pick whichever matches your tooling.

How is LLMWiki different from RAG or Notion AI?

RAG retrieves chunks from documents at query time. Notion AI summarizes pages on demand. LLMWiki maintains a persistent, hand-readable Markdown wiki that grows over time, written by the LLM and read by future LLM sessions. The wiki is the source of truth, not the raw documents. It's closer to 'compiled knowledge' than 'retrieved knowledge' — slower to build but cheaper and more coherent at query time.

Why did this pattern blow up in April 2026?

Three reasons converged. (1) Long-running coding agents like Claude Code, Codex, and Cursor 3 produce huge session logs that nobody reads. (2) MCP made it trivial to give an LLM read-write access to a folder. (3) Karpathy posted a clean gist on April 28, 2026 articulating the pattern, and the open-source community shipped working implementations within 48 hours. The pattern names something engineers were already drifting toward.

Quick Answer

What is LLMWiki? Karpathy's AI Knowledge Pattern (Apr 2026)

Published: April 30, 2026

What is LLMWiki? Karpathy’s AI Knowledge Pattern (April 2026)

The hot AI pattern of late April 2026 isn’t a tool — it’s a workflow. Andrej Karpathy described it as the LLM Wiki pattern in a public gist, and within 48 hours multiple open-source implementations hit GitHub. Here’s what it actually is and how to use it.

Last verified: April 30, 2026

The short answer

LLMWiki is a pattern where:

Raw sources go in — notes, transcripts, agent session logs, web clippings, code snippets.
An LLM continuously maintains a structured Markdown wiki summarizing the sources, indexing concepts, and cross-linking topics.
Future LLM sessions read the wiki first instead of re-reading raw sources.

The wiki is human-readable Markdown. The LLM is the librarian. You can read it. Other LLMs can read it. It grows, gets edited, and becomes the compiled knowledge layer between your raw input firehose and your AI agents.

Why this is different

Not RAG

RAG (retrieval-augmented generation) chunks documents, embeds them, and retrieves the closest matches at query time. The LLM never restructures the source material — it just searches it.

LLMWiki rewrites the material into a structured Markdown wiki. The wiki has its own organization: topics/, people/, projects/, decisions/. Cross-links connect related entries. The LLM does the organizing work once and amortizes it across all future queries.

Not Notion AI

Notion AI is a feature that summarizes a page on demand. LLMWiki is the pattern of letting the LLM own the entire knowledge base, with a fixed schema (Markdown files in folders) and a continuous compaction loop.

Not just memory

Memory frameworks like Mem0 or Letta store conversation context. LLMWiki stores the distilled output of work — like a research notebook a postdoc maintains for their advisor.

The mechanics (from Karpathy’s gist)

The pattern, simplified:

sources/                # raw input
  meeting-2026-04-28.md
  paper-on-mcp.pdf
  cursor-session-3829.txt
  slack-export-week-17/

wiki/                   # LLM-maintained
  index.md              # entry point, table of contents
  topics/
    mcp.md
    cursor-3.md
    nemotron.md
  people/
    karpathy.md
  decisions/
    2026-04-15-switched-to-claude-code.md

A nightly job (or an LLM agent) runs:

Look at new files in sources/.
Decide which existing wiki entries to update and which new entries to create.
Cross-link entries with [[wiki-style links]].
Write a brief changelog of what was added.

You read the wiki yourself. Other agents read the wiki when they need context. The raw sources stay around but are rarely consulted directly.

Why it blew up in April 2026

Three forces converged:

1. Coding agents produce too much context to read

Claude Code, Codex, Cursor 3, and Gemini CLI all produce session transcripts that are individually long and collectively unreadable. An agent that ran for 4 hours generates a transcript no one will ever open. LLMWiki turns that transcript into one or two updated wiki pages.

2. MCP made file-system access trivial

Model Context Protocol matured through 2025-2026. Any compliant client (Claude Desktop, Cursor, Codex, Claude Code) can read and write a local folder via an MCP filesystem server. Building an LLM that owns a Markdown folder went from “weekend project” to “compose two MCP servers.”

3. Karpathy named it

On April 28, 2026, Karpathy published a gist articulating the pattern. He didn’t invent it — engineers had been drifting toward similar workflows for months. But naming it crystallized the design space, and the open-source community shipped within 48 hours.

Open-source implementations (as of April 30, 2026)

Project	What it does
karpathy/llm-wiki (gist)	The original spec. Read this first.
Pratiyush/llm-wiki	Turns Claude Code, Codex CLI, Copilot, Cursor, and Gemini CLI sessions into a wiki. Rebuilds on every push.
lucasastorian/llmwiki	Upload documents, connect Claude via MCP, the LLM writes the wiki.
tjiahen/awesome-llm-wiki	Curated list of all current LLM Wiki tools, schemas, and implementations.
gbrain + gstack (Saeloun)	Karpathy-style private wiki built on Rails + AI workflow.

Expect 10x more implementations within weeks.

How to build your own (April 2026)

A minimal working LLMWiki, in three pieces:

1. Pick a folder structure

~/wiki/
  index.md
  topics/
  people/
  decisions/
  meta/
    schema.md     # how the wiki is organized
    log.md        # changelog of LLM edits

2. Pick an LLM with file-system MCP

Any of these work in April 2026:

Claude Desktop or Claude Code + filesystem MCP server.
Cursor 3 Agents Window with /worktree to isolate writes.
Codex CLI with the fs plugin.
Local model (Llama 5, Qwen 3.6) via Ollama + a custom MCP filesystem.

3. Write a “wiki maintainer” prompt

Something like:

You maintain a Markdown wiki at ~/wiki/. On every run:

Read ~/wiki/meta/schema.md to understand the structure.

Look at new files in ~/inbox/ (raw sources).

Update or create wiki pages, using [[wiki links]] for cross-references.

Append a one-line changelog to ~/wiki/meta/log.md.

Move processed files to ~/inbox/processed/. Be conservative: never delete a wiki page, never overwrite without diff. Use topics/ for concepts, people/ for individuals, decisions/ for choices and rationale.

Run it nightly via cron, or on-demand via your editor.

What it’s good for

Coding agent session compaction — turn 4-hour Claude Code transcripts into a one-page summary.
Research notes — papers and blog posts go in raw, structured topics come out.
Personal knowledge management — the postdoc-notebook use case Karpathy described.
Team knowledge bases — replace abandoned Notion wikis with an LLM-maintained one.
Agent context bootstrap — point new agents at your wiki on session start, skip the “read 50 files first” warmup.

What it’s not good for

Live collaboration — wiki pages are slow-changing; concurrent edits get messy.
Highly structured data — invoices, transactions, tables. Use a database.
Anything regulatory — LLM-edited prose is not a system of record.
Fast retrieval at scale — past ~10K pages, you still want vector search on top.

How LLMWiki relates to existing memory tools

Tool	Role
Mem0 / Zep / Letta	Per-conversation agent memory
RAG	Retrieval over raw documents at query time
Notion AI	On-demand summarization of pages
LLMWiki	Persistent, LLM-compiled, human-readable knowledge layer

These are complementary. A serious agent stack in 2026 uses memory (Mem0/Letta) for conversation state, RAG for raw document search, and LLMWiki for compiled long-term knowledge.

Bottom line

LLMWiki is the most important AI workflow concept named in April 2026. It is not a product, it is not magic — it’s the obvious right thing to do once your LLM can read and write a folder. If you run AI agents that produce more text than you can read, start with the karpathy/llm-wiki gist this week.

Built with 🤖 by AI, for AI.