OKF Made the Easy Part Free and the Hard Part Invisible

Google Cloud shipped the Open Knowledge Format in June, and the reaction told you everything about what the agent-tooling world believes its real problem is. A directory of Markdown files. YAML frontmatter. One required field. Karpathy's LLM-wiki gist, now with a spec, an Apache 2.0 license, and a logo. Within a day the posts arrived: infrastructure for digital brains, exactly what I've been asking for, the thing that finally kills the integration tax. The engineering is clean and the instinct behind it is sound. The format does what it claims. My problem is with what the celebration assumes, which is that serialization was ever the part holding anyone back.

It wasn't. Every knowledge-representation standard of the last twenty-five years learned this lesson, and OKF is about to learn it again on a faster clock. The format was always cheap. The bill was always curation: the human judgment that decides what is true enough to write down, plus the unglamorous standing cost of keeping that judgment from rotting. OKF doesn't pay that bill. No format can. What it does instead is stranger and more dangerous. By rendering every document identical regardless of where the document came from, it makes the unpaid bill harder to see, exactly as it hands the pen to agents.

The integration tax was real, and it was the small one

Give OKF its due first, because it earns some. The context-assembly problem is genuine. In most organizations the knowledge an agent needs is scattered across data catalogs, wikis, code comments, Slack, and the heads of three senior engineers who are in a meeting. Every new RAG or agent stack reinvents how to represent a table, a metric, a runbook, and that reinvention is pure waste. OKF removes it. A vendor exports a catalog as an OKF bundle, your agent reads it with no connector, and the same files render on GitHub and diff in a pull request. Sam McVeety and Amir Hormati named the target precisely and shipped real tooling against it: a BigQuery enrichment agent, a static HTML visualizer, three sample bundles built on public datasets. This is competent work and the interoperability it buys is worth having.

Now size what got fixed. Integration friction is a tax, and taxes are irritating, not lethal. The thing that actually kills a knowledge base was never the cost of writing the connector. It was the cost of the knowledge being wrong, propagating quietly, and nobody noticing until something acted on it. OKF makes the cheap problem cheaper and says almost nothing about the expensive one.

Where the semantic web actually died

We have run this experiment before. RDF, OWL, the entire W3C semantic web, and Dublin Core before all of it. The promise each time was a machine-readable representation layer so software could traverse meaning instead of scraping for it. The semantic web did not die because triples were too hard to author, though they were. It died because the triples rotted. Someone had to keep them true, nobody owned that job, and the graph drifted from reality until the only people who could have used it stopped trusting it.

The enterprise data catalog is the identical story with a sales team bolted on. Collibra, Alation, and Atlan each sold a single governed source of metric and schema truth. The software shipped. The catalogs filled. Then the definitions went stale, because curation is a recurring cost that no quarter ever budgets for, and a stale catalog is worse than no catalog, since it lies with a straight face and an authoritative UI.

OKF is a Markdown re-run of the same wager with the same unsolved dependency sitting underneath it. Google is admirably honest that the format is the contribution and that pipelines, governance, and freshness are left to you. That honesty is the tell. The hard part has, once again, been scoped out. I made this argument in a different register in The Loop Was Never the Hard Part : automating the mechanism is the easy half, and the judgment the mechanism was wrapped around is the half that refuses to automate. OKF automates the filing cabinet. The decision about what deserves to be filed is still sitting on a person's desk, and the format just made it easier to skip that person entirely.

Schema.org worked because Google paid for it

There is one apparent counterexample, and it looks devastating until you ask why it actually worked. Schema.org did not rot the way RDF did. More than a decade on, millions of sites still mark their pages up with it, and the markup is mostly current. The vocabulary was not better designed than RDF's. What differed is that Google attached a reward to keeping it accurate: rich results, eligibility for better placement in the one arena every business on earth is desperate to place in. Curation got funded because freshness paid for itself, page by page, in traffic. The forcing function was external, economic, and impossible to ignore.

OKF has no such forcing function. Knowledge Catalog ingesting it natively is a Google-internal convenience, not an industry-wide reason to keep your bundles true. The incentive simply is not there. Nothing in the design rewards the org that keeps its OKF documents accurate over the org that lets them drift, and the second org is the cheaper one to be. Absent a reward for freshness, freshness does not happen. That is not a small omission. It is the difference between schema.org and every standard that quietly died in a working group.

Nobody owns the bundle

Set the format aside for a second and ask the operational question, the one the excited threads skip. Who in the company actually maintains an OKF bundle once it exists? Data engineering has a backlog and does not want a documentation mandate. The platform team owns pipes, not meaning. The docs team, where one still exists, lacks the schema knowledge. And the senior engineers whose heads hold the real definitions are the most expensive people in the building to ask and the least likely to volunteer for upkeep. OKF assumes a curator who keeps the bundle honest, and most organizations do not have that role, have never had it, and will not invent it on the strength of a Markdown spec.

So the bundle gets generated once by the enrichment agent, looks complete on day one, and ages from there. The format made the artifact trivial to produce, which removes the last scrap of friction that used to force a human to at least glance at the thing before it shipped. A document that is free to generate and owned by no one does not get maintained. It gets abandoned in place, while still being read as truth.

The frontmatter that launders provenance

Open any OKF document and look at what the format actually records. The single required field is type. The optional set is title, description, resource, tags, and timestamp. Two reserved filenames, index.md for navigation and log.md for chronological history. That is the contract. Now notice what the contract leaves out. There is no field for who decided this. None for whether anyone checked it. None for how confident the claim is. And no signature binding the assertion to an accountable author.

The consequence is precise and ugly. A metric definition a senior data engineer reasoned through for an hour, and an agent's confident guess from a doc it half-read, carry byte-identical frontmatter. The format is provenance-neutral. That phrasing sounds like fairness. It is corrosive. Provenance neutrality means the format strips the single most important attribute of any knowledge claim, the warrant standing behind it, and then presents the verified and the unverified as the same kind of object.

Call it knowledge laundering. The round trip runs from a low-confidence, machine-generated assertion, into a clean Markdown file with tidy YAML, and back out as authoritative context, with the uncertainty washed off somewhere in transit. Either way, the file looks identical. The consuming agent has no field to read that would let it ask the only question that matters, which is whether to believe this. A frontmatter that omits provenance is not minimal. It is a laundering layer with excellent ergonomics.

Marc Bara , writing on the launch, drew a sharp line between structural and semantic interoperability and observed that OKF advances the first while leaving the second to convention. He is right, and there is a third axis sitting under both that nobody is naming. Call it provenance interoperability: the ability of a consumer to mechanically trust where a claim came from. OKF advances exactly none of it. Worse than semantics, provenance cannot be recovered after the fact. Once the warrant is gone from the document, no downstream tool can reconstruct it from the text.

Agents writing the files that agents read

This stops being hypothetical the moment you read what the flagship reference implementation does. The BigQuery enrichment agent walks a dataset, drafts an OKF concept document for every table and view, then runs a second LLM pass that crawls documentation and writes the description for each concept. The canonical way to produce an OKF bundle, shipped by the format's own authors, is to have a language model generate the knowledge.

Now close the loop the ecosystem is openly excited about. Agent frameworks are racing to support OKF bundles as a native datasource. So the producing agent writes a plausible description, the file format launders the uncertainty out, and the consuming agent ingests the result as ground truth and acts on it. No human stands anywhere between the guess and the action.

We have a name for what happens to a system fed on its own unverified output. It is model collapse. Shumailov and colleagues put it in Nature in 2024: indiscriminate use of model-generated content causes irreversible defects in what comes out, with the tails of the real distribution vanishing first. That paper was about training data. The same mechanism operates one layer up, on an organization's knowledge substrate, when agents author the documents that other agents consume and nobody re-grounds any of it against reality. The living wiki everyone wants becomes a wiki that increasingly cites itself.

Make it concrete. The enrichment agent drafts a definition for weekly_active_users and, not having the actual business rule in front of it, writes a reasonable-sounding one that counts sessions instead of distinct people. It lands in the bundle as a clean concept document: type: metric, confident description, no flag, no caveat. A downstream agent assembling the weekly leadership report reads that definition as canonical and produces a number that is wrong in a specific, directional way. Nobody wrote the wrong number. The agent did, faithfully, from a laundered definition no human ever confirmed. Multiply that across every table and metric in a real warehouse and you do not have a knowledge base. You have a confident answer generator with no idea which of its answers are load-bearing.

The failure does not announce itself. A confabulated join key, a metric definition that is subtly off, an API caveat that was true two quarters ago and silently is not anymore: all of it rendered in exactly the same confident Markdown as the things that happen to be correct. Drift here is not a bug you will get paged for. It is the default behavior of the system operating as designed.

The blast radius does not even stay inside your walls. SEO and platform people are already exposing public /okf/ endpoints so external agents can crawl them, treating OKF as a richer schema.org for the agent web. Stack that on the laundering problem and you are no longer just poisoning your own agents. You are publishing machine-written, unverified claims for everyone else's agents to ingest as authoritative, and llms.txt, the other fashionable machine-readable layer, has the same hole in the same place. The uncertainty leaks outward, signed by nobody.

Git is not provenance, and optional is not a standard

Two rebuttals arrive immediately, and both are weaker than they look on the way in.

The first: just add a provenance field, the spec is intentionally thin and extensible. But an optional field that no consumer is obligated to check is not provenance. It is a comment. The entire value of a standard is that a consumer can rely on what the standard asserts. A verified_by that three vendors implement three different ways, and that any producer is free to omit, hands you the appearance of provenance with none of the guarantee, which is strictly worse than absence because it invites trust it has not earned. Provenance has to be load-bearing inside the type contract or it does not bind anything. OKF v0.1 put type in that slot and nothing else.

The second: Git already gives you authorship and history. It does not. Git tells you which commit and which account produced a byte change. It says nothing about whether the claim was verified by someone who understands the domain, and the consuming agent does not read git blame regardless, it reads the file. When the enrichment agent commits under a service account, the history faithfully records that a machine wrote the document and tells you exactly nothing about whether the document is right. Authorship answers what keystrokes occurred. Provenance answers whose judgment, checked how. Those are different questions, and only the second one keeps you out of trouble.

This is the same confusion I went after in the bearer-token piece from another direction. An agent presenting a credential proves possession, not legitimacy. An OKF document presenting clean frontmatter proves format compliance, not truth. The industry keeps mistaking the envelope for the contents, and keeps being surprised when the envelope turns out to be empty.

What a provenance layer would actually take

The fix is not exotic, and I have built a version of it. Verifiable knowledge needs three things the format currently lacks, and all three have to be mandatory rather than optional, or you are back to laundering.

A signature, binding each claim to an accountable identity, human or agent, so a consumer can tell a definition a domain owner stands behind from one a crawler drafted at 3 a.m. A confidence and a verification state, so an unreviewed agent draft is legibly different from a human-confirmed fact instead of dressed identically to it. And a source trace, a link back to the pre-curation material, the query result, the ticket, the meeting note, the decision, so a claim stays auditable to its origin instead of floating free of it. When a definition gets challenged six months later, you want to land on the decision that produced it, not on a commit hash that only tells you a bot wrote it.

None of this is research. The W3C Verifiable Credentials work already gives you the signing primitive off the shelf. I built an evidence spine on exactly this premise for a credentialing system, an outcome registry plus signed attestations plus a public proof surface, because in a regulated domain an unsigned claim is not knowledge. It is a liability you have not priced yet. This is the Verification Renaissance the Map has been tracking , the shift where verifiability becomes the differentiator rather than raw capability, arriving now at the knowledge layer.

The producers building OKF tooling for finance, healthcare, and DevOps will hit this wall first and hardest, because those are the domains where a wrong definition has a cost with a name and sometimes a regulator attached to it. The correct sequence is a complementary layer that captures warrant and traceability before the clean OKF document ever gets written, the thing a few people were already sketching on launch day as context hooks. Format first and provenance bolted on later is precisely the ordering that produces collapse. By the time the document exists, the warrant that should have been captured has already evaporated. You cannot sign a claim whose origin you have already forgotten, and an enrichment agent forgets by design the instant it moves on to the next table.

What to watch

Track one thing above all others. Watch whether the next versions of OKF make provenance a required primitive or leave it, permanently, to the community, which in standards-speak means it never binds and the laundering stays load-bearing forever.

Watch whether the competing formats that are coming, and they are coming the instant OpenAI or Anthropic or some independent consortium decides interchange is worth owning, choose to compete on provenance rather than on ergonomics. Ergonomics is a solved problem. Trust is not. Watch which enterprises adopt naked OKF: the unregulated ones will move fast and some will get away with it, while the banks and the hospitals and anyone whose definitions eventually sit in front of an auditor should refuse any knowledge format that cannot sign its own claims, and the sharp ones will.

Watch the public side of this too, not only the internal one. If /okf/ endpoints become a norm the way sitemaps did, the open web acquires a fresh layer of confident, unsigned, machine-written claims that other models will scrape, train on, and then quote back to users as established fact. That is model collapse with a distribution channel attached.

The format wars of the next two years will not be won on how easy a bundle is to write. They will be won on whether you can trust what is inside it.

A digital brain that cannot tell a memory it verified from one it confabulated is not a brain. It is a liability with excellent syntax. OKF made it free to write an organization's knowledge down and left wholly untouched the one thing that was ever expensive, which is the slow human work of knowing that what you wrote is true. The Markdown was always the cheap part. The bill came due the moment we let agents hold the pen, and no folder of files is going to settle it.