OKF: The New Standard That Makes AI-Powered Personal Wikis Shareable

A few months ago Andrej Karpathy published a short GitHub gist with an idea: build a personal knowledge base where an AI agent doesn't just store documents, but reads every new source, extracts what matters, and updates a linked wiki of markdown files with it. That simple gist picked up roughly 40,000 stars, and anyone who tried it found they could paste it straight into a coding agent and get a working wiki built in one shot. The problem that showed up once everyone started building: no two LLM wikis looked the same, so none of them could be shared. Google's Open Knowledge Format (OKF) is aimed squarely at that gap.

What an LLM wiki actually is

Karpathy's idea is simple: instead of dumping documents into a database and doing standard RAG, you let an agent build and maintain a linked collection of markdown files itself. At the top sits an index file the agent reads first on every search - a list of every document with a short summary, so the agent knows where to dig deeper. Below that sit entity pages - a tool, a concept, a project - each with metadata up top (title, tags) and links to related pages. Feed in a new source - a meeting transcript, a planning doc, an article - and the agent doesn't just file it away; it reads it, pulls out what matters, and updates the relevant entity pages. Over time that builds a knowledge graph the agent can traverse.

The problem: every wiki is built differently

Because Karpathy's gist is an idea, not a spec, everyone who builds their own LLM wiki ends up with a slightly different result. One person calls the tag field tags, another calls it categories. One builds an index per folder, another builds a single global index. Those differences sound minor, but they break sharing entirely: if an agent doesn't know exactly how the wiki it's handed is structured, it can't search it efficiently - it has to dig into the metadata first to figure it out, and often it just doesn't. Without a shared standard, there's no real way to give a team one common wiki, move a wiki between tools (Obsidian, Notion), or hand someone a ready-made wiki they can query immediately.

The fix: Open Knowledge Format

OKF standardizes exactly two things, nothing more: how information is organized, and which fields metadata must contain. On organization, OKF says every folder gets its own index file, plus one top-level index pointing to all the folders (the spec calls a packaged knowledge collection like this a bundle). On metadata, every document starts with YAML front matter, and exactly one field is required: type - the document's category (concept, video, and so on). Everything else - title, tags, related items - is optional but recommended, because those are what give an agent a reliable way to filter and navigate. That's the actual strength of OKF: it doesn't tell you how to think about your knowledge, it only defines how to tag it so any agent can read it.

Building or converting a wiki into OKF

Just like Karpathy's original gist, OKF ships as a single spec.md file in a GitHub repo. You take the file, paste it into a coding agent, and ask it to build a new wiki in that format - or convert an existing one. The file effectively functions as a skill: it teaches the agent the terminology, how to structure bundles, and how to write correct front matter. It scales to large existing wikis too - just ask the agent to split the work across several sub-agents, each handling a different section of the knowledge base, converting everything in parallel.

Bundles: what sharing actually looks like

Once a wiki follows OKF, it can be packaged as a bundle and handed to someone else - a team, a community, an audience. The idea is simple: a creator can package a set of videos or articles into one bundle, publish it on GitHub, and let anyone pull it into their own second brain with a single prompt - no need to feed in transcripts themselves. The agent reads the README, already understands the structure because it knows OKF, and starts answering questions immediately. The same principle works internally too: a team can maintain one shared bundle everyone queries, instead of each person building their own version of the same knowledge.

The "it's too simple" critique - and why that's the point

The most common critique of OKF is that it doesn't add much on top of Karpathy's original idea - mostly folder organization rules and one required field. That critique is technically accurate, and it misses the point. OKF isn't trying to be a sophisticated knowledge engine - it's a minimal interoperability layer. Being minimally opinionated is exactly what makes it useful: it doesn't force a specific structure, it only guarantees that two different agents can read the same wiki the same way.

The takeaway

If MCP gave AI agents a shared language for talking to tools, OKF is trying to give them a shared language for talking to knowledge bases. There's no guarantee this particular Google format is the one that survives long-term - but the direction is clear: as more people build LLM-powered second brains, a shared standard for structure and metadata stops being a nice-to-have and becomes what turns personal knowledge from something only you can use into something anyone else can query too.