Awesome LLM Wiki

A curated list of foundational blueprints, functional frameworks, and technical guides for building compounding, AI-compiled knowledge bases.

Inspired by a paradigm shift in software development engineering, this architecture treats large language models not as ephemeral chat engines, but as stateful knowledge compilers. Instead of parsing fragmented document partitions dynamically at runtime via traditional RAG loops, these systems leverage autonomous agents to read static source files and systematically construct an interlinked, persistent Markdown knowledge topology.

Contents

• Foundations
• Articles and Guides
• Specifications and Standards
• Tools and Plugins
  • Libraries and Frameworks
  • Applications and Desktop Clients
  • CLI Tools and Core Compilers
  • Hosting and Infrastructure Platforms
  • Agent Skills and System Rules
• Live Implementations and Reference Vaults
• Research and Papers
• Videos
• Podcasts

Foundations

Foundational whitepapers, conceptual architectures, and structural blueprints outlining static agentic compilation.

• Andrej Karpathy's LLM Wiki Gist - The foundational idea file laying out the core pattern, operations, and architecture for compounding AI knowledge bases.
• Farza's Personal Wiki Skill - A functional blueprint for implementing an LLM wiki compiler using Claude Code skills, including commands for ingestion, absorption, and automated cleanup.
• LLM Wiki v2 - An architectural extension of Karpathy's blueprint focused on scale, memory lifecycles, confidence decay, and typed knowledge graphs.

Articles and Guides

Technical examinations, exhaustive architectural deep-dives, and detailed workflow overviews.

• Andrej Karpathy Wiki: LLM Wiki Concept Guide - A conceptual breakdown embedded inside the live Karpathy encyclopedia detailing the explicit operating models, file structures, and automated compilation loops that define a production-grade LLM Wiki setup.
• Automate AI Second Brain (LLM Wiki Pattern) With Claude Code and Obsidian - An advanced guide transitioning the LLM Wiki pattern from interactive commands into an automated background operating system. Details how to orchestrate automated morning briefings and evening debriefs using Anthropic Cloud Routines, steer background agents with structured priority maps, and integrate live external context using Google Calendar and Gmail MCP servers.
• Build an AI Second Brain (LLM Wiki Pattern) With Claude Code and Obsidian - A practical implementation blueprint executing the LLM Wiki pattern using Claude Code as a vault maintainer. Demonstrates how to configure text-based slash commands (/ingest, /query, /lint, /log) to manage the boundary lines between raw input stores and compiled concept nodes while establishing hard citation tracking across file line coordinates.
• Build an LLM Wiki for Your AI Agents with myKG and Obsidian - An implementation guide introducing the open-source myKG library to enforce type-safe ontologies in local vaults. Demonstrates how to run automated pipeline integrations for Claude Code using terminal skill configurations, establish explicit source traceability records, and configure numerical confidence tracking metrics to eliminate silent agent hallucinations.
• Build your AI Brain (Leo Alexandru) - A comprehensive production case study implementing a customized Karpathy LLM Wiki using the Claude Code CLI. Outlines a five-layer folder taxonomy, a flat permanent note topology, and a twelve-part modular agent skill ecosystem (.claude/skills/) to drive automated multi-stream file compilation (/wiki-compile), structural link linting (/wiki-lint), and contextual content generation.
• Building an 'Agent Only' Obsidian Vault (The Thinkers Club) - A technical architectural guide defining a human-agent sandbox paradigm. Details a methodology for isolating autonomous AI writers inside a dedicated secondary vault to compile a self-organizing wiki of consumed data, preventing context contamination and layout drift in human-authored notes.
• Commonplace - A technical framework establishing the theory of deploy-time learning for bounded AI observers, detailing semantic distillation operations, and providing automated CLI workspace management skills.
• Compiling knowledge, not retrieving it (Roan Brasil Monteiro) - A code-level implementation guide detailing the software architecture of the llm-wiki-compiler engine. Walks through the step-by-step orchestration of a multi-model text compilation loop, local workspace linting rules, and inline source-provenance tracking without vector databases.
• Create Your AI Brain Today - The final part of a structural context trilogy pinpointing why knowledge management setups fail at the content layer. Focuses on content architecture optimization, detailing how to engineer high-signal markdown nodes, construct type-safe frontmatter blocks for explicit entity tracking, and implement strict data compression filters to protect agent context windows from token bloat.
• Customizing Karpathy's LLM Wiki for Fighting Disease (Ben Kamens) - A deep-dive production case study auditing the Karpathy flat-file wiki pattern under dense medical domain data. Details custom multi-modal ingestion strategies for complex clinical trial papers, multi-agent mutation strategies to resolve overlapping disease-symptom relationships, and deterministic verification protocols to enforce absolute factual integrity without relying on external relational databases.
• From Karpathy's LLM Wiki to a Working Second Brain: My Implementation with Amazon Quick Desktop - Dima Kramskoy's step-by-step production review of a local flat-file LLM wiki automated via Amazon Quick Desktop and served locally using MkDocs. Details a four-tier ontology schema (concepts, entities, projects, sources) and implements an elegant visual diff-approval ingestion pipeline that treats the agent as a local workspace code contributor while preserving absolute human state control.
• Give Your AI Unlimited Updated Context - An operational architecture guide exploring decoupled, portable text vaults. Outlines the strategic benefits of maintaining plain text markdown knowledge graphs over proprietary, model-siloed memories, detailing how to utilize root configuration files (CLAUDE.md) and automated background agent loops to keep cross-functional context updated natively.
• How to Build an AI Brain That Never Forgets - A practical implementation blueprint detailing how to build an air-gapped, local Obsidian memory vault. Walks through extracting conversational data streams from proprietary web platforms, configuring root-level orchestration instructions (CLAUDE.md), and deploying background automation scripts to sync data sources and log daily workflow progress.
• How to Build an LLM Knowledge Base (DAIR.AI) - A practical workshop guide defining a standard local directory architecture and outlining repeatable agentic compiler patterns.
• Karpathy shares 'LLM Knowledge Base' architecture (VentureBeat) - The foundational tech journalism coverage analyzing Andrej Karpathy's autonomous archive philosophy. Details the engineering advantages of substituting dense vector RAG with an evolving, AI-maintained local Markdown wiki to prevent context-limit lobotomies in developer prompt streams.
• Karpathy's LLM Wiki as Agent Memory - A conceptual framework published by the Agentic AI Foundation mapping the LLM Wiki pattern to cognitive agent memory architectures. Explains how directory boundaries transform flat markdown files into distinct functional memory layers—mapping schemas to procedural execution rules, logs to episodic records, and cross-linked entity directories to semantic graph memory.
• Karpathy's LLM Wiki v2: What to Keep - A critical architectural teardown outlining the evolution of the LLM Wiki design pattern. Details the necessary shift from manual workflows to parallel background agent pipelines, explains how to replace heavy index rewrites with vector mapping arrays, and demonstrates how to implement a targeted JSON pre-routing layer to keep API context costs minimal as local vaults grow past thousands of nodes.
• Karpathy's LLM Wiki: The Complete Guide (Agentpedia Codes) - An exhaustive breakdown analyzing the three-layer architecture, comparing static compilation vs. traditional RAG, and detailing prompt configurations.
• LLM Knowledge Bases (DAIR.AI) - A detailed breakdown of the four-phase compilation pipeline (Ingest, Compile, Query, Lint) with architecture diagrams and implementation workflows.
• Obsidian: Your AI Second Brain isn't Memory (Roan Brasil Monteiro) - A deep-dive system design guide mapping out the engineering mechanics of an active knowledge compiler loop over passive vector RAG. Formulates why standard semantic search layers cause context decay, providing a clean blueprint for building deterministic, git-backed file topologies in plain Markdown.
• Self-Authoring LLM Knowledge Bases - A technical conceptualization extending the compilation loop to live developer conversations, transforming ephemeral terminal and editor interactions into structured, persistent memory.
• The Real Second Brain: An Autonomous Knowledge Engine - An architectural essay defining the paradigm shift from ephemeral chat interfaces to persistent, agent-driven local wikis. It details how flat-file markdown vaults serve as a deterministic long-term memory layer for autonomous daemons, allowing collaborative, human-in-the-loop knowledge compilation and state management.
• What is LLM Wiki Pattern? Persistent Knowledge with LLM Wikis - A structural guide defining the core filesystem architecture and ingestion loops of the LLM Wiki pattern. Outlines the read/write boundaries between raw source directories and compiled wiki spaces, detailing a 5-step compilation pipeline and contrasting the pre-compiled text routing method against traditional single-pass vector RAG pipelines.
• What Karpathy's LLM Wiki is Missing (And How to Fix It) (Penfield Labs) - A deep architectural critique outlining solutions for token scaling limits in file-based context stores, featuring code patterns for semantic deduplication and pre-commit syntax hooks to protect structural integrity.

Specifications and Standards

Official architecture blueprints, industry standards, and schema specifications formalizing flat-file, agent-ready knowledge layout structures.

Open Knowledge Format (OKF)

• Open Knowledge Format (OKF) v0.1 Specification - The official technical blueprint by Google Cloud defining an open, vendor-neutral standard for human- and agent-friendly knowledge bundles. Outlines the exact structural contracts for a file-based layout: directories of raw Markdown documents, mandatory type definitions in YAML frontmatter, standard horizontally linked graph paths, and reserved structural control protocols like index.md and log.md.
• How the Open Knowledge Format Can Improve Data Sharing (Google Cloud Blog) - The official announcement and contextual release brief introducing OKF v0.1. Outlines the industry-wide problem of fragmented AI context landscapes and formalizes the Karpathy LLM-wiki pattern into an enterprise-accepted format for decoupling knowledge generation from proprietary database frameworks.

Tools and Plugins

Software utilities, automation scripts, and development plugins for structuring and maintaining LLM wikis.

Libraries and Frameworks

Code-first SDKs, programmatic pipelines, and developer libraries used to orchestrate or validate local context vaults.

• codejunkie99/agentic-stack - A framework providing a unified, portable .agent/ directory structure to standardize local memory, skills, and protocols across multiple environments (such as Claude Code, Cursor, and Windsurf). Features a multi-layered local file storage engine, an automated configuration syncing CLI, and self-improving pattern-clustering workflows that keep knowledge persistent across different development tools.
• Graphify - A multi-modal knowledge graph compilation engine that handles codebase AST parsing via tree-sitter alongside media transcription, producing localized agentic subgraphs to yield up to a 71.5x token efficiency gain.
• LLM Research Wiki - A typed Python graph pipeline and framework engineered for complex literature mapping. Enforces a rigid 6-tier academic document topology via Pydantic schemas, features automated cross-link validation, and exports a native MCP server optimized for piping structured research vaults into Claude Code and Cursor.
• OpenKB (Website) - An open-source Python CLI knowledge base framework that compiles multi-format documents into interlinked markdown vaults using a specialized tree-based index for vectorless long-document retrieval.
• SenolIsci/mykg - An open-source neuro-symbolic knowledge graph extraction library that converts mixed-format document folders (.pdf, .docx, .md) into confidence-scored, ontology-grounded Obsidian vaults. Features a two-pass pipeline separating RDFS/OWL schema induction from instance extraction, built-in disk-state checkpoint recovery, and a deterministic code-based validation layer to completely eradicate link hallucination.
• Tesserae - A statically-typed Python framework and pipeline engine for building, validating, and maintaining LLM wikis. Features Pydantic schema enforcement for page metadata, programmatic agents.md configuration assembly, an extensible workspace linter suite, and built-in MCP protocol adapters.

Applications and Desktop Clients

Dedicated graphical user interfaces, standalone desktop environments, and visual editor shells.

• Cabinet - A free, open-source, file-based AI knowledge workspace that implements Karpathy's compilation loop, featuring git-backed auto-commits, scheduled agent automation cron-jobs, an integrated browser terminal, and embedded HTML application injection.
• LLM Wiki (Nash Su) - A cross-platform Tauri desktop application that turns multi-format documents into interlinked markdown vaults, featuring two-step chain-of-thought ingestion, interactive Louvain community graphs, and an async human-in-the-loop review system.
• Memento - A self-hosted, local-first engine that compiles decades of local email data into an organized knowledge base across People, Projects, and Concepts. It runs deterministic graph and parsing algorithms to map connection structures, allows text narrative enrichment via local LLMs, and exposes its underlying FTS data directly to terminal agents over structural search tools.
• nohmitaina - A local-first macOS desktop Markdown editor built to implement Karpathy's LLM Wiki pattern natively alongside Claude Code or Codex, featuring automated background concept extraction, cross-reference mapping, and workspace contradiction linting.
• OpenKnowledge (Website) - An open-source, local-first IDE and markdown editor designed explicitly for co-authoring long-term memory vaults with AI agents. It features a dual-observer CRDT architecture for real-time, lossless visual text synchronization alongside automated agent updates, packages native Model Context Protocol (MCP) servers to expose folder structures to external assistants, and leverages git-backed version control to ensure complete data privacy and sovereignty.
• Row-Bot - A local-first desktop AI assistant and workbench that centers its persistent memory layer around an integrated Personal Knowledge Graph. It features background "dream cycle" compilation routines that automatically extract, deduplicate, and update local knowledge files, offering native, Obsidian-compatible wiki vault exports alongside tool orchestration hooks.
• talirezun/the-curator (Companion Article) - A full-stack, locally-hosted knowledge curation application that automates the Karpathy LLM Wiki pattern via an accessible browser GUI. Features an automated Atomic Decomposition pipeline separating files into interconnected Entity, Concept, and Summary nodes, built-in Obsidian graph visualization setups, and an integrated private Model Context Protocol (MCP) server bridge to expose local vaults directly to external AI clients.
• whoami.wiki (GitHub) - An open-source, private life-archiving system that converts digital data dumps (photo vaults, chat logs, bank transactions, and location histories) into a local personal encyclopedia. Uses autonomous agent pipelines to cross-reference unrelated metadata timelines into highly detailed, interlinked markdown pages complete with standard Wikipedia-style information sidebars, event logs, and relationship networks.
• Wikikarp - A dedicated desktop application wrapper for the Karpathy LLM Wiki pattern. Automatically compiles raw notes and scratchpads into structured, cross-referenced markdown vaults, managing local file mutations, index building, and localized query routing directly on top of your flat-file directory.
• Wikiwise (Website) - A native macOS Swift application that wraps markdown directories into a fully browsable personal wiki interface, featuring a file-watcher compilation engine, cross-link indexing graph panels, and an embedded agent shell panel.

CLI Tools and Core Compilers

Terminal utilities, command-line automation scripts, and event-driven background compilation daemons.

• agent-wiki-cli - A CLI framework designed to build and maintain self-correcting flat-file markdown knowledge bases. Implements automated multi-format ingestion pipelines, two-pass semantic graph compiling, lint checking for broken linkages, and native slash-command hooks for AI terminal agents.
• AI Research OS - A file-driven multi-agent research framework and compilation engine. It aggregates local notes, codebase snapshots, and web captures into an immutable raw directory, generating a mirrored, highly interconnected LLM Wiki layer composed of flat markdown concept nodes and a unified YAML schema map to optimize downstream context validation.
• Atomic - An open-source, self-hosted personal knowledge base built in Rust that transforms freeform markdown notes into a semantically linked graph, featuring asynchronous chunking pipelines via sqlite-vec, auto-generated tag wikis with inline citations, an integrated MCP server, and a force-directed canvas.
• AutoSci - An advanced, memory-centric autonomous scientific research platform powered by Claude Code. Implements a dual-layer markdown vault architecture (SciMem) to separate long-term scientific knowledge from active project frames, featuring multi-model critique validation loops, rigid Pydantic-style front-matter schema definitions, and a continuous self-evolution pipeline.
• Beever Atlas (Website) - An open-source, self-hostable conversational knowledge compiler and MCP server that transforms Slack, Discord, and Teams chat streams into a structured Neo4j knowledge graph and an auto-generated Markdown wiki with granular permission mirroring.
• browzy.ai - An open-source, self-hosted TypeScript knowledge compiler designed to ingest messy digital data streams and compile them into a structured, self-organizing personal memory layer.
• ByteRover (Website) - An open-source, file-based local memory engine and interactive CLI tool that compiles codebase interactions into a hierarchical Context Tree, featuring agent-native curation, an adaptive knowledge lifecycle layer, sub-100ms hybrid text retrieval, and multi-IDE MCP portability.
• CacheZero - An automated second brain framework built directly around the Karpathy LLM Wiki pattern. It features a custom browser extension to capture web sources, an automated compilation engine that uses local LLMs to generate structured markdown vaults with explicit [[wikilinks]], and an integrated MCP server for terminal agent querying.
• claude-obsidian - An open-source Claude Code plugin and knowledge engine that builds compounding Obsidian vaults, featuring hot-cache context persistence, multi-agent batch ingestion, automated 8-category vault linting, and spatial canvas orchestration.
• codeglance - A codebase compilation utility that dynamically extracts structural maps, code blocks, and layout metadata from a local directory. It outputs a deterministic, flat-file "readable wiki" and a token-optimized AI context brief explicitly formatted for agentic ingestion.
• Cosma - An open-source, command-line document graph compiler that parses local plain-text folders with [[wiki links]] and YAML metadata into interactive, self-contained HTML/JS visualization networks. Features contextual backlink maps, automated citation processing, advanced focus filtering, and zero-dependency static builds perfectly optimized for publishing agent-managed knowledge bases.
• digital-me-dream-cycle - An offline, LLM-powered knowledge distillation and maintenance compiler engineered to automate vault cleanup. Implements a background "sleep state" routine that scans local Markdown files and YAML metadata configurations to resolve cross-session information conflicts, distill fragmented daily logs into high-signal wiki nodes, and continuously repair broken links or semantic orphans.
• Enzyme - A local-first memory indexer that compiles folder structures, backlinks, and tags into pre-computed concept "catalysts," providing sub-millisecond local context lookups and automated skill integration for Claude Code and Codex.
• GBrain - An open-source, markdown-first AI agent memory layer and knowledge graph compiler. It processes raw document directories, transcripts, and data captures into structured plain-text nodes, using zero-LLM entity extraction to map typed connection edges and an automated background "dream cycle" to handle profile enrichment, gap analysis, and citation repair across local agent frameworks.
• GitNexus (Website) - A zero-server, client-side code intelligence engine that compiles entire repositories into a structured knowledge graph and automated markdown wiki, utilizing local WebAssembly databases and an MCP server to provide deep architectural awareness to coding agents.
• jackwu321/Quant_LLM_Wiki (PyPI) - A specialized implementation of the Karpathy LLM Wiki pattern engineered specifically for quantitative finance research. Features multi-source ingestion of trading PDFs, web links, and financial articles into a local Markdown vault using strict domain-specific metadata schemas, inline LaTeX mathematical formatting, and a dedicated "Rethink Layer" for continuous strategy auditing, validation tracking, and post-mortem charting.
• Karpathy LLM Wiki (Website) - A native Obsidian community plugin implementing Andrej Karpathy's three-layer wiki memory architecture entirely client-side. It parses vault files to extract atomic entity and concept pages, builds a deterministic bidirectional link topology, features an inline conversational streaming query interface with traceably cited links, and supports full local data sovereignty when routed through Ollama or LM Studio.
• Klore - A Python-based CLI knowledge compiler that structures multi-source research inputs into markdown files, featuring native configuration rule injectors for Cursor, Windsurf, and Copilot, alongside a dedicated Claude Code slash-command plugin.
• knowledge-worker - A local-first, python-based memory compiler designed to preserve context across separate agent sessions without database sprawl. It stores highly structured knowledge graphs inside portable, flat JSON files, utilizing a mandatory human-in-the-loop review gate and strict document-level excerpt provenance to eliminate hallucinated entity extraction and long-term memory drift.
• Link (Website) - An open-source local memory engine and MCP server for terminal agents that compiles assets into markdown vaults, featuring built-in graph visualizations, automated structural health healing, and rigorous local security sanitization.
• Linkly AI (Website) - A lightweight local document search engine and MCP server that compiles filesystem data into an AI-ready context layer, featuring progressive outline indexing, fast multilingual fuzzy matching, and deep regex terminal grep filtering.
• LLM Wikid - A multi-phase shell compilation framework for Obsidian vaults that implements automatic inbound media extraction, programmatic categorization routing, and mandatory cognitive bias countermeasure modules.
• LLM Wiki (Dom Leca) (Forum Post) - A native Obsidian community plugin implementing Karpathy's compilation pattern locally via Ollama (Qwen 2.5 + Nomic Embed), featuring real-time event-driven background extraction, multi-modal hybrid search, and persistent natural language chat interfaces.
• LLM Wiki (nvk) - An open-source core engine and CLI toolkit implementing whole-topic archive lifecycle management, deep workspace linting with structural auto-repair capabilities, and platform-specific path environment diagnostics.
• llm-wiki-compiler (Atomic Memory) - A TypeScript CLI tool and MCP server that compiles raw text into structured markdown wikis, featuring paragraph-level source provenance tracking, multi-provider model routing, and a rule-based workspace linter.
• llm-wiki-tools - A localized Python CLI utility suite realizing the Karpathy "knowledge as code" blueprint. Operates strictly on a local three-tier directory hierarchy (updates/, raw/, wiki/) to facilitate surgical block-level patching via STDIN, featuring an integrated schema linter, automated source file archiving, and native markitdown ingestion.
• llmwiki (Lucas Astorian) - An open-source Python engine and local web dashboard that indexes directories into a local SQLite repository, serving a specialized MCP adapter to automate Claude-driven wiki compilation and citation tracking.
• lorewiki - A local-first knowledge base engine optimized for LLM-assisted development loops. It utilizes a hybrid retrieval architecture matching structural file hierarchies with local SQLite FTS5 and BM25 token search to parse and serve exact codebase context blocks without cloud databases.
• Matryca Plumber - An enterprise-grade, local-first background AI maintenance daemon and native FastMCP server for Logseq graphs. Directly handles direct Markdown AST block mutations with integrated Optimistic Concurrency Control, featuring background dangling link healing, zero-LLM link rot lints, a local cockpit UI, and deep developer optimization for Claude Code.
• Memora - A lightweight open-source MCP memory server that decomposes markdown files into structural semantic fragments, featuring automated tool schema sanitization, real-time graph visualizations, and automated LLM-driven deduplication.
• obsidian-knowledge - An open-source Python automation toolkit that tracks file configurations and packs directory trees within local Obsidian vaults into streamlined context frames optimized for terminal coding agents.
• obsidian-wiki - A pip-installable Python framework that transforms any local Obsidian vault into a cross-agent knowledge base. Deploys unified markdown skill primitives across Claude Code, Cursor, Windsurf, and Pi to execute automated document processing, multi-hop graph queries, structural link linting, and automated conversational history mining.
• Obsidian Second Brain (Deep Dive) - A powerful cross-CLI skill suite for Claude Code, Codex, and Gemini that updates, reconciles, and rewrites existing vault notes dynamically to enforce a compounding local knowledge graph, featuring 34 terminal commands and write-time document validation.
• Patina (Deep Dive) - A high-performance, single-binary Rust CLI tool explicitly designed around the Karpathy LLM Wiki pattern. It utilizes memory-mapped reads to parse local markdown directories and extract frontmatter metadata, compiling deterministic in-memory connection graphs with zero heavy database sidecars.
• PieKBS (Docs) - A local-first knowledge search engine for agents that distills raw documents into structured Markdown wikis via LLM. Features FTS5 full-text search, graph-based document expansion via citation/support/wiki links, multi-hop tag expansion, and native MCP server integration. Pure Go binary with no external dependencies.
• pi-llm-wiki - A production-grade, local-first knowledge base extension and MCP server for the pi ecosystem, Claude Code, and Cursor. Converts raw files, PDFs, and links into a 4-layer Obsidian-compatible markdown topology, featuring automated cron-driven ingestion (/wiki-ingest), workspace link linting, and an opt-in trajectory distillation loop for capturing agent tool-call sequences.
• Pieces - A local-first developer context and snippet manager driven by an on-device Long-Term Memory (LTM) engine, exposing workflow history, auto-tagged codebases, and structural metadata to external agents via an integrated MCP server.
• QMD - A local-first, mini CLI search engine and MCP server for markdown knowledge bases that combines BM25 full-text filtering, vector semantic search, and on-device LLM re-ranking.
• SwarmVault (Website) - A local-first RAG knowledge base compiler and MCP server that maps files into an interlinked Markdown wiki and SQLite-backed knowledge graph, featuring automated linting, local graph visualizations, and a compounding "file-back" exploratory architecture.
• Synto - A 100% local, Ollama-native knowledge compiler and memory layer featuring an asymmetrical dual-model compilation pipeline, SHA-256 mutation defense to protect manual human edits, an interactive terminal review TUI (synto review), and a native 8-tool MCP server designed to pipe structured vaults into Claude Code and Cursor.
• Tolaria - An open-source, Git-first desktop markdown app and native MCP server engine built with Tauri and Rust, implementing structural file conventions, automatic AGENTS.md generation, and secure local file boundaries for agent processing.
• twillm - A TiddlyWiki-powered local knowledge management wrapper explicitly built around the Karpathy LLM Wiki pattern. It watches an Obsidian-compatible directory of flat-file Markdown nodes to dynamically compile live query filters and interactive dashboards, eliminating index file staleness across parallel human and AI agent editing loops.
• Understand Anything - A highly advanced, cross-platform multi-agent compilation engine and plugin suite for Claude Code, Cursor, and Gemini CLI. Uses a deterministic Tree-sitter and LLM hybrid pipeline to synthesize directories into local, versionable knowledge-graph topologies, featuring a dedicated /understand-knowledge framework for parsing and visualizing community clusters within Karpathy-pattern markdown wikis.
• vault-curator - A local, python-based knowledge system compiler that transforms massive Markdown vaults into self-organizing environments for AI agents. It processes flat-file directories to automatically inject structural frontmatter metadata, compute semantic connection links, and compile persistent Maps of Content (MOCs) to optimize downstream agent retrieval.
• yologdev/yopedia - A full-stack Next.js and TypeScript wiki application built entirely by autonomous agents. Implements a dual-surface architecture combining a human-readable Markdown layer (featuring inline citations, validation rules, and decay parameters) with an agent-consumable Model Context Protocol (MCP) server containing 28+ specialized data tools. Runs an ongoing multi-agent loop via GitHub Issues with a strict, automated shell-testing harness that handles continuous ingestion, claim linting, and automatic code reverts.

Hosting and Infrastructure Platforms

Remote publishing layers, deployment environments, and multi-agent access infrastructure for file-based knowledge vaults.

• Agent Wikis - A production-deployed knowledge platform built around the "Git as a database" flat-file pattern. It hosts public, human-readable wikis that anyone can browse for free to learn from, while serving the underlying raw markdown via MCP for autonomous agent ingestion. Features a closed-loop engine that tracks missed agent queries to fuel automated research and patching workflows behind human-gated commit approvals.
• Portable LLM Wiki - A vendor-neutral, cloud-first hosting platform that compiles personal markdown notes and profiles into portable, agent-ready context endpoints. It surfaces hosted vaults via universal URLs and QR code bundles that can be directly consumed by terminal assistants like Claude Code and Cursor, utilizing a multi-agent background linting engine to automatically audit cross-note contradictions, verify wiki-link topology, and maintain strict document-level provenance.
• wikihub.md - A specialized hosting and collaboration platform designed specifically for flat-file LLM wikis. Features instant markdown publishing via Git or drag-and-drop, a robust per-file access control system using a .wikihub/acl (CODEOWNERS-pattern) schema, and an agent-native REST API that allows autonomous systems to dynamically read, query, and modify deployed knowledge vaults securely.

Agent Skills and System Rules

Procedural instructions, system schemas, and behavioral configuration definitions engineered to teach autonomous terminal models how to natively compile, link, and maintain flat-file knowledge bases.

• Engram - An open-source Claude Code skill suite that captures digital touchpoints and social threads, automatically parsing and compiling them into an interlinked, structured Obsidian knowledge vault.
• LLM Wiki (TrueHOOHA) - An open-source implementation focused on mitigating agent behavioral drift using rigid workflow skills. Features a triage-first ingest mechanism (wiki_import / wiki_wrapup), automated cross-page contradiction reports, a single-command wiki_fix cleanup loop, and SHA-256 source provenance tracking.
• MehmetGoekce/llm-wiki (Companion Article) - A production-grade implementation of the Karpathy LLM Wiki pattern for Claude Code with out-of-the-box support for Logseq and Obsidian. Implements a dual-layer hardware cache model that splits knowledge into hot system memory (L1 via CLAUDE.md) and an on-demand on-disk filesystem (L2), complete with automated shell ingestion, multi-stage search routing, an index eviction engine, and a 11-rule automated semantic linter.
• Memory OS - A 7-layer local memory operating system built for Hermes Agent. It unifies trust-scored SQLite facts, session histories, and local vector retrieval with an automated, self-curating LLM Wiki pipeline that compiles system insights directly into flat markdown notes, allowing users to manually audit and edit their agent's long-term memory structures using desktop markdown editors like Obsidian.
• NousResearch/hermes-agent (Research Wiki Skill) - A first-party, natively bundled system skill that brings the Karpathy LLM Wiki pattern to the Hermes Agent ecosystem. Features batched parallel ingestion, strict bi-directional [[wikilink]] creation rules, automatic file size splitting thresholds, and explicit contradiction handling protocols that isolate conflicting claims for human review while maintaining out-of-the-box compatibility with Obsidian and Logseq vaults.
• owledge - An open-source automation framework and behavioral runtime configuration package for agent frameworks. It enforces structured memory execution boundaries through system lifecycle hooks, utilizing strict namespace profiling and context-lane mappings to ensure independent multi-agent daemons read, write, and cross-link flat markdown concept nodes without creating directory collisions or unstructured data drift.
• sametbrr/llm-wiki-manager - A production-grade implementation of the Karpathy LLM Wiki pattern packaged as a native Claude Code and agentskills.io skill. Bundles a suite of dependency-free, idempotent Python scripts for automated workspace scaffolding, index catalog synchronization, transaction ledger logging, and semantic linting capable of parsing standard markdown links and Obsidian double-bracket nodes.
• Wiki Builder (DAIR.AI) - An open-source Claude Code plugin path that automates directory scaffolding, handles multi-flavor workspace indexing, and leverages localized markdown configuration files to govern agent compilation boundaries.

Live Implementations and Reference Vaults

Production-deployed examples and open-source markdown templates demonstrating the LLM Wiki pattern in active human-agent workflows.

• Andrej Karpathy Wiki - A live, self-growing encyclopedia mapping Karpathy's public work using a markdown-first, Cognee-backed knowledge vault. It acts as an operational reference blueprint for the LLM Wiki pattern, featuring background query-synthesis workflows that autonomously format, link, and compile source inputs back into flat markdown files.

Research and Papers

Peer-reviewed scientific literature, algorithmic formalizations, and empirical benchmark evaluations of compilation-based knowledge loops.

• DeepRefine: Agent-Compiled Knowledge Refinement via Reinforcement Learning - A foundational paper addressing compounding structural decay in long-lived agent knowledge bases. Proposes a reinforcement learning framework that interacts with a pre-constructed wiki to perform abductive error diagnosis and localized refinement actions, optimized via a Gain-Beyond-Draft (GBD) reward policy to heal broken links, coreferences, and factual anomalies.
• Retrieval as Reasoning: Self-Evolving Agent-Native Retrieval via LLM-Wiki - The foundational paper formalizing the Karpathy LLM Wiki design pattern into a production architecture. Introduces the Three Principles of Agent-Native Retrieval (Compilability, Composability, Evolvability) and details a system that converts unstructured documents into interlinked markdown pages, utilizing a persistent "Error Book" loop for cross-batch structural self-correction and multi-hop tool traversal.
• Vector RAG vs LLM-Compiled Wiki: A Preregistered Comparison on a Small Multi-Domain Research Corpus - A preregistered empirical benchmark evaluating a chunk-vector RAG baseline against an LLM-compiled Markdown Wiki. Demonstrates that while the Wiki architecture exhibits an extreme query-time token cost asymmetry, it provides vastly superior cross-paper synthesis and unprecedented claim-level citation accuracy compared to single-round similarity lookup frameworks.
• WiCER: Wiki-memory Compile, Evaluate, Refine Iterative Knowledge Compilation for LLM Wiki Systems - A foundational paper characterizing the "compilation gap" and attention dilution in long-context KV cache LLM Wiki deployments. Proposes an iterative, CEGAR-inspired compilation loop that automatically evaluates workspaces against diagnostic probes, isolates dropped facts, and injects them as cumulative structural preservation constraints, reducing catastrophic failure rates by 55%.
• WikiKV: Schema-Evolving Path-Indexed Storage for Hierarchical Knowledge Navigation (Tencent/WeChat) - A foundational database-tier paper formalizing the storage, optimization, and evolution constraints of LLM-curated hierarchical wikis. It introduces a path-as-key encoding model to achieve single-round-trip lookups, details automated continuous structural evolution through programmatic split and merge operators, and demonstrates production validation backing the WeChat Assistant framework.

Videos

Visual walkthroughs, conceptual code execution guides, and theoretical video essays.

• 10 Easy Ways to Enhance Your LLM Wiki or Knowledge Base (Tonbi's AI Garage) - A masterclass tutorial breaking down 10 core enhancements for file-based knowledge stores. Features an architectural breakdown contrasting the embedding mathematics of Vector RAG against the agentic compilation loops of LLM Wikis, alongside live setups for DataView dashboards, native Mermaid flowcharts, and background MCP Vault integration.
• Build an OKF Brain Like Mine! (Deep Dive) (Marie Haynes) - A practical video case study exploring a live implementation of Google's Open Knowledge Format as a sovereign personal memory engine. The walkthrough demonstrates an automated ingestion pipeline that splits inbound web references into atomic markdown concept nodes, uses persistent playbooks to guide downstream agent behavior, and leverages human-in-the-loop review boundaries to prevent data corruption.
• Google's OKF: The New Way to Structure Your Knowledge for Agents (Marie Haynes) - A high-level technical analysis of Google's Open Knowledge Format (OKF) specification. Explains how the standard formalizes the Karpathy LLM Wiki pattern into a cross-organizational directory structure of plain-text markdown files, enforcing strict YAML frontmatter metadata and atomic concept-splitting to optimize downstream agent traversal.
• How To Build LLM Wiki In Obsidian? (Wanderloots) - The definitive video tutorial mapping out the core 3-tier local memory architecture, showcasing how to build a file-based ingestion pipeline, implement a Git-backed maintenance loop, and deploy an agentic vault firewall wrapper.
• Is Karpathy's viral LLM wiki helpful? Kinda yeah. Feedback one month in. (Companion Article) - A deep-dive 30-day technical review tracking a 760-page agent-managed knowledge vault built on top of Quartz. Explores the explicit scaling limits of the pattern, detailing the setup of background monitoring crons, automated append-only ledgers, and strict linting rules that treat uncited text blocks as structural pipeline errors.
• I Built a Digital Brain Upload Using Karpathy's LLM Knowledge Base (Tonbi's AI Garage) - A deep dive video applying the Karpathy LLM Wiki pattern to private, multi-platform personal communication trails. Demonstrates how to write custom scripts to parse Google Takeout .mbox archives, agent logs, and .jsonl interactive terminal loops into an air-gapped, local Obsidian twin, mapping the user's stylistic voice patterns and tracking operational frustration loops over time.
• I Trained an AI on Everything I've Ever Said Online (Semi Autistic Vibe Coder) - A detailed implementation video showing how to ingest personal multimedia histories into a Karpathy-pattern local wiki. Integrates OpenAI's Whisper and Claude Code to parse raw video transcripts and JSON archives, compiling the data into a flat Obsidian folder topology (concepts/, entities/, sources/) utilizing automated meta-logging hooks and structural schema policies.
• Karpathy's LLM Wiki: What It Means & How to Build One (Tonbi's AI Garage) - A practical video guide on bootstrapping an LLM Wiki from scratch inside Claude Code, demonstrating automated multi-agent ingestion loops, backfill routines for external web research, and visual chart integrations.
• Turn 10,994 Notes Into Memory - AI Research OS Workshop (AI Engineer) - A comprehensive technical walkthrough breaking down a file-driven AI memory architecture. The presentation details how to construct an intentional three-layer LLM Wiki using flat markdown directories and a central YAML indexing schema to completely bypass vector database complexity while enforcing an ultra-token-efficient agent retrieval loop.
• Why LLM Wiki? Future Of Knowledge For Agentic AI & Humans (Wanderloots) - A visual guide explaining the mechanics of nodes, edges, and triples, the token-efficiency of GraphRAG over standard RAG, and a workflow for sandboxing human vs. agentic Obsidian vaults.

Podcasts

Audio-first breakdowns, developer interviews, and strategic discussions exploring the design, implementation, and everyday use of LLM Wiki architectures.

• Episode 429: Getting started with LLM Wikis (Microsoft Cloud IT Pro Podcast) - An operational teardown of the LLM Wiki architecture tailored for enterprise environments. Explores how to wire up Obsidian Web Clipper and automated RSS monitors to create active collection channels, utilizes Copilot Cowork background loops to handle daily inbox synthesis, and provides an analysis of the compliance risks of decoupling text assets from corporate Data Loss Prevention (DLP) and sensitivity governance.

Contributing

Contributions are welcome! Please ensure all pull requests strictly follow the formatting guidelines specified in the repository workflow files.