Andrej Karpathy quietly posted a gist describing an LLM wiki: a personal knowledge base, kept as plain markdown, that a language model maintains for you. Two months later, Google Cloud published the Open Knowledge Format, an open specification that formalizes precisely that pattern and credits the same source. One was a developer sharing a personal habit. The other is a standard. They are the same idea at two different scales, and the idea is one I have been circling for months.

In Architecture Is the Prompt I argued that the context agents need was never something you had to buy. It was the corpus you were already supposed to keep: plain text, in git, where you control it. That post was about architecture diagrams and decision records. This week the same shape showed up as a general format for all text-based knowledge, and it arrived with a name. So this is the post where the argument stops being mine and starts being a spec.

The Bookkeeping Was Always the Problem

Start with Karpathy’s gist, because it is the cleaner version of the insight. His LLM wiki has three parts. Raw sources stay immutable, the articles and PDFs you feed it. The wiki itself is a set of markdown files the model writes and rewrites: summaries, entity pages, concept pages, cross-linked with wikilinks. And a schema file, a CLAUDE.md, tells the model the conventions: how to ingest, how to link, how to keep the index honest.

The reason this matters is in one line. As Karpathy puts it, the tedious part of maintaining a knowledge base is not the reading or the thinking, it is the bookkeeping. Every personal wiki, every team Confluence, every shared drive dies the same death: the upkeep cost grows faster than the value, a human stops paying it, and the thing rots. The new fact is that the bookkeeping is exactly what a model does for free. “LLMs don’t get bored, don’t forget to update a cross-reference, and can touch 15 files in one pass.” The maintenance cost falls toward zero, and a knowledge base whose maintenance is free is a knowledge base that survives. The human role narrows to the part humans are good at: curating the sources and asking the questions.

That is the personal second brain, finally made durable. Not by a better app, but by handing the chore that always killed it to something that does not tire.

I already built one of these. Clerko, the agent I built for my son, uses exactly this pattern as its memory. Every interaction it has gets written into a markdown wiki the model maintains for itself, cross-linked into a graph it compiles and then queries to remember what came before. I did not set out to implement Karpathy’s gist. I set out to give an agent a second brain that survived between conversations, and the structure I arrived at was his, because it is the one that works. Reading the gist later was less a new idea than a name for the thing already running in my homelab.

A Pattern Becomes a Standard

What Karpathy described as a personal habit, Google wrote down as a format. The Open Knowledge Format is deliberately, almost aggressively, minimal. Knowledge is a directory of markdown files with YAML frontmatter. Each concept is one file, and the file path is the concept’s identity. Files link to each other with ordinary markdown links, and those links make the directory a graph. The only required field is the concept’s type. The full v0.1 spec fits on a page.

The design principles are the part worth reading twice, because they are the same principles I keep arguing for. “Format, not platform.” It “will never require a proprietary account or SDK to read, write, or serve.” And the line that gives the whole thing away: “the value of a knowledge format comes from how many parties speak it, not from who owns it.” This is not a product trying to capture you. It is a convention trying to be spoken. Google even separates who writes the knowledge from who reads it, so a file a human hand-authored, a file a pipeline exported, and a file one model wrote can all sit in the same corpus and be read by another.

It is just markdown. Just files. Shippable as a tarball, hostable in any git repo, readable in any editor, and parseable by any agent, with no translation layer between the human view and the machine view. If that sounds familiar, it should.

The Same Medium, All the Way Down

This is the part I want to claim, because I have been building toward it. In Architecture Is the Prompt the argument was that twenty years of compliance-forced documentation turned out to be a corpus, and that the C4 model and the decision log, kept as plain text in git, were the context an agent reads. The Open Knowledge Format says the same medium holds everything else: a table, a dataset, a metric definition, a runbook, an API, a business process. Not a special store for each, with its own proprietary export. One format, for all of it, legible to a person and an agent at the same time.

That is the quiet radicalism of a markdown standard. The semantic web tried to make knowledge machine-readable and failed because authoring was a separate, miserable job that no human kept up. Enterprise knowledge management captured everything into formats retrieval could not use. I walked through that fifty-year cycle of near-misses in Context Engineering Is Infrastructure. The thing that breaks the cycle is not a richer schema. It is a poorer one: a format simple enough that the machine maintaining it never balks, and human enough that you can still read the diff. The corpus was the prompt. Now the corpus has a file format, and it is the one your code already lives next to.

From the Second Brain to the Team Brain

Here is the move that makes this more than a personal-productivity story. The format does not change as you scale it. Karpathy’s wiki is a second brain for one person. The exact same markdown-and-frontmatter-in-git is a team brain for a department, and the same again is the knowledge layer for a company. You do not graduate from your personal note-taking system to an enterprise knowledge platform with a migration and a six-figure license. The personal system is the enterprise format. The only thing that grows is the graph.

That continuity is the whole prize. Because producer and consumer are decoupled, your private notes and the metadata your data platform exports and the runbook your colleague wrote all land as the same kind of object. The team brain is not a different technology from the second brain. It is the second brain with more authors, and the same near-zero maintenance cost that saved the personal wiki is what lets the team one stay alive where every Confluence before it died.

The Team Brain Is Miessler’s Lattice

Scale that idea to a whole organization and you arrive at something Daniel Miessler has been describing as the lattice: a structure where every tier of a company, the individual, the team, the department, the whole, broadcasts what it knows and does as queryable knowledge. SOPs, metrics, goals, and expertise captured as reusable skills, each tier authoritative over its own. Turn the chaos of a company into a corpus you can query in seconds, and the work that used to require chasing five people across three meetings becomes a question with an answer.

Miessler’s sharpest point is the one that connects straight back to Karpathy. “The real barrier between human expertise and AI expertise is not capability. It’s capture.” The intelligence is already here. What is missing is the expertise locked in people’s heads, never written down in a form anything else can use. And capture has a ratchet to it: once an expert’s judgment becomes a documented skill, it never goes back in the bottle. It is permanently in the pool, available to every agent at once, while the human version took decades to build and leaves when the person retires.

A capture problem needs a capture format. That is what the Open Knowledge Format is, and it is why this is not just a tidy way to keep notes. It is the file format for the lattice. I made a narrower version of this case in The Documentation Dividend: the institutional memory a bank is forced to write down for the regulator is the same memory its agents will query, so the compliance work pays a second time. The lattice is that dividend taken to its conclusion, and now there is a standard for the files it is paid in.

Why Captured Structure Beats Raw Text

The skeptic’s question is whether any of this changes outcomes, or just tidies the shelves. The numbers say it changes outcomes. dbt ran a 2026 benchmark pitting raw text-to-SQL against the same questions answered through a captured semantic layer. On multi-table-join questions, raw text-to-SQL fell to around sixty-five percent accuracy. The captured layer answered its in-scope questions at essentially one hundred. But the line that matters for anyone in a regulated seat is about the shape of failure: “With text-to-SQL, failure looks like a plausible but incorrect answer. With the Semantic Layer, failure looks like an error message.” Captured knowledge does not just make the agent more right. It makes the agent’s wrongness loud instead of silent, which in a bank is the difference between a caught defect and a reported one.

This is why the people funding the next layer of infrastructure are converging on the same word. Andreessen Horowitz argues that data agents need context as first-class infrastructure, a superset of the old semantic layer rather than a feature bolted onto a dashboard. The model is not the scarce thing anymore. The captured, structured, owned context you point it at is. I argued in the Build verdict that as raw intelligence commoditizes, the moat moves up to context. A portable format for that context is how you make sure the moat is yours and not the platform’s.

What This Costs You, Which Is Almost Nothing

The practical part is the reason I am writing this instead of bookmarking it. For a small team, the cost of starting is a CLAUDE.md and a handful of markdown files in a repo you already have. Your knowledge layer becomes a thing you diff, review in a pull request, and check in CI, living exactly where your code-review discipline already lives. You do not stand up a platform. You write files. The second brain you build for yourself this week is, byte for byte, the format your team brain will speak next quarter, because there is no second format to migrate to.

For a regulated shop the upside compounds. Definitions you can diff are definitions you can audit. Knowledge in a neutral text format is knowledge you can hand an examiner or a partner without dragging them into your stack. And the capture discipline itself, the habit of turning a senior engineer’s intuition into a written, versioned concept, is the thing Miessler’s ratchet rewards and the thing your key-person-risk register has been begging for anyway.

What I Cannot Promise You

The honest caveat, because the thing is four days old. The format is open. The governance is not yet settled: this is a v0.1 that Google published, wired into its own Knowledge Catalog, and pointed its own enrichment agents and serving layer at. As one early read put it, the move gives away the part that was never scarce, a file any editor can open, and points demand at the part Google sells: the layer that stores the knowledge, serves it to agents, and decides who may see it. An open format with no neutral steward is a good intention, not a guarantee, and whether a foundation ever stewards this one is an open question I cannot answer this week.

But notice what that critique does not touch. The file is still yours. You can adopt the pattern without adopting anyone’s runtime, keep the corpus in your own git, and serve it with whatever you like. The open part is the part that matters, and the open part is the part you get to keep. Treat the serving layer as a convenience you can replace and the format as the asset you own, and the lock-in worry mostly dissolves.

Capture Was Always the Point

Trace the line from Karpathy’s gist to Miessler’s lattice and the through-line is a single word: capture. The personal second brain and the company-wide knowledge layer are the same act of writing expertise down in a form a machine can keep, performed at different scales. We spent fifty years failing at it because the bookkeeping was a human chore nobody sustained. The chore is now free. The medium, it turns out, was always plain text in git, the same place I keep arguing your most valuable context already lives. This week it got a spec. The only real question left is whether you start capturing now, while the format is young and the advantage compounds, or after everyone else’s lattice is already full.

---

If this resonated, the companion read is Architecture Is the Prompt. That post was about the architecture corpus agents read. This one is about the format the whole knowledge layer is written in.

If you are building a second brain or a team brain on something like this, or you have a view on whether an open format survives without a neutral steward, I want to compare notes. Find me on X @orestesgarcia or LinkedIn /in/setsero.