In this explainer, Cole Medin covers Google's Open Knowledge Format (OKF), a newly released open standard that formalizes Andrej Karpathy's LLM wiki pattern into plain markdown any AI agent can read and share. Karpathy's original idea, a single markdown gist that reached roughly 40,000 stars on GitHub, lets an LLM incrementally build and maintain a persistent, interlinked personal knowledge base (a "second brain"). The problem: everyone who builds one structures it differently, so no two wikis are shareable. OKF fixes that by defining a simple, shared standard on top of the Karpathy pattern, doing for agent-to-knowledge-base communication what MCP did for agent-to-tool communication.
type. Everything else (title, tags, related videos) is optional. type provides categorization so an agent can filter and search by document category like a knowledge graph.spec.md from Google's repo, hand it to a coding agent, and tell it to build a new OKF wiki or refactor an existing one. The spec acts like a skill that teaches the agent the standard.A couple of months before this video, Andrej Karpathy released the idea of the LLM wiki: a pattern for building personal knowledge bases with LLMs. It took off, and the single markdown gist on GitHub reached about 40,000 stars. Medin notes you can copy that file, paste it into a coding engine, ask it to build an LLM wiki, and it will essentially one-shot the result, which makes it very easy to get started.
Rather than dumping documents or indexing content for a RAG, the LLM helps build something smarter: it incrementally builds and maintains a persistent wiki of structured, interlinked markdown files. As you add sources over time (meeting transcripts, plan documents, articles), the agent does not just index them. It reads each file, extracts key information, and integrates it into the existing wiki, updating entity pages so there is a knowledge graph for the agent to traverse and remember important information.
At the top of every wiki is an index file the agent maintains whenever it brings in new information. The agent reads this first almost every time it searches the knowledge base. The index gives a high-level overview of every document (an article name plus a quick summary) so the agent can decide what to drill into based on the user's request. Metadata like title and tags lets it filter, for example, to just documents in a "security" category. Links to related concepts at the bottom of each document create the graph view that shows how entities connect. Because the LLM does the tedious work of understanding related concepts and maintaining links, you do not need to be technical or spend much time maintaining it.
The catch is that an LLM will not build the same system another person's LLM builds. The way related concepts are linked, how information is structured, even the metadata can differ. Medin's example: one person uses a tags field while another uses categories. That small difference can mean that if you hand your knowledge base to another person's agent, it will not know how to search categorically. It would have to dive into the metadata first to understand the structure, and it might not decide to do so. These little mismatches compound when people do not share the same metadata or folder structure. A standard means everyone builds wikis the same way so they can be shared freely.
OKF is Google's answer, and Medin calls it beautifully simple, a lightweight standard built on top of the Karpathy wiki idea. It standardizes two things. First, how information is organized: entity documents, concepts, and the use of indexes both within folders and at the top level. Second, the exact metadata fields tagged at the top of every document, so an agent can query by title or tags and traverse the wiki like a knowledge graph. Categorization is one of the most important pieces because it lets the agent move through the wiki intelligently.
Each OKF document carries YAML front matter at the top. The single required field is type, which gives categorization (for example, concept or video) so the agent can search over just videos or just concepts, which becomes powerful in larger bundles. All other fields (title, tags, related videos) are optional and are how entities are linked together under a consistent standard. Even when optional fields are absent, an agent that was given the spec and taught to be an OKF consumer knows how to leverage whatever fields exist for better searching.
Medin stresses that OKF is a standard both for consuming knowledge bases (searching through them) and for producing them (evolving the wiki over time and building up entity pages, as Karpathy described). He frames the analogy directly: what MCP did for agent-to-tool communication, OKF does for agent-to-knowledge-base communication. He believes it is the future of personal agents, and even if OKF specifically does not become the eventual standard, something like it will, so it is worth understanding now.
To build with OKF, create a new knowledge base, or refactor an existing one, you use the spec.md file in Google's repo. Like Karpathy's gist, you copy the document, paste it into your coding agent, and tell it to build a wiki following the Open Knowledge Format or refactor an existing one. The spec functions like a skill: it teaches the coding agent the terminology, how to structure bundles, and how to build the YAML front matter and per-document attributes such as tags. It is a single source of truth, and because the standard is simple, agents (Medin references models like GPT-5.5 and Opus 4.8) do not get confused working through it, even though the file is fairly long.
The size of an existing knowledge base does not matter for refactoring. You can specifically ask the agent to use sub-agents to work through different sections of the knowledge base in parallel and convert them to OKF. That makes it easy to scale and to have the agent rip through the spec regardless of how large your current wiki is.
The biggest benefit of OKF is sharing wikis with other people. An OKF wiki is called a bundle. Medin built and shared (as a gift, via a GitHub repo linked in the description) a bundle that packages up his favorite AI coding YouTube videos. His point: many viewers already skim transcripts and feed them into their second brain to ask questions, so pre-packaging curated sets of videos as bundles makes that easier. To use it, you first give the spec to your coding agent so it teaches itself OKF, then point it at the bundle repo and paste a prompt telling it to read the repo and set everything up. Because the agent already understands OKF, it brings the bundle into your local Obsidian or Notion and you can immediately start asking questions without importing transcripts yourself. Medin sees this as the easiest way for content creators to share their knowledge.
Medin adds a light layer of organization on top of OKF for managing many bundles: a top-level document describing how his OKF bundles work, an index of the bundles he has, and a simple CLI script (included in the example bundle) to list bundles, view a specific index, and read a file by bundle and concept ID. Otherwise he follows the format exactly, giving him two layers of indexing. The example bundle is intentionally small, with two sections: four of his best, most up-to-date AI coding videos, and concepts (recurring ideas extracted into their own entity pages). The index lists the sections rather than every individual file, letting the agent read the index within concepts or videos, list files, or do a keyword search.
One concept in the bundle is the PIV loop (plan, implement, validate), the primary mental model Medin teaches for AI coding: have a process to plan, implement, and validate whatever you build with a coding agent. He demonstrates progressive disclosure in his terminal. He first asks what bundles he has (the agent runs the CLI tool to list them), then asks a broad question, "the single biggest idea for getting reliable code out of an AI coding assistant," without naming a bundle. The agent runs four commands: it reads the AI coding index, follows the index to the concepts, decides context engineering is the key idea, reads the context engineering concept, and returns the final answer. It starts with almost no context and drills down to exactly what is needed. That, Medin says, is what OKF gives you as a standard.
Medin acknowledges one critique he considers valid: many people say OKF is too simple, that it does not add much substance on top of the Karpathy wiki. He grants the point, noting that what OKF really does is speak to exactly how you organize files, specifically indexes within folders plus a top-level index. He also candidly notes that Google is lagging in the raw AI race (he considers Gemini not as good as GPT and Claude), but argues Google has been strong at releasing guidance on how to leverage LLMs effectively, a different lane than building the best models, and one worth leaning into.
type is the single required field in OKF metadata; title, tags, and related links are optional.Medin's argument is that the Karpathy LLM wiki was a breakthrough for personal knowledge bases, but it lacked a standard, which made wikis impossible to share and interoperate reliably. Google's OKF supplies that standard in a deliberately simple form: standardized organization plus standardized YAML metadata with a single required type field. Adoption is as easy as handing the spec.md to a coding agent to build or refactor a wiki, and the payoff is shareable bundles and cleaner progressive-disclosure search. Even if OKF is not the format that ultimately wins, Medin believes a standard like it is the future of personal agents and is worth adopting now.