Google shipped version 0.2 of the Open Knowledge Format (OKF) last week, and on the surface it has nothing to do with search. It is a spec for data teams: a way to store the context AI agents need (table schemas, metric definitions, runbooks) as plain markdown with a bit of structured metadata on top, so that context lives in an open format instead of some proprietary service.
If you stop there, it is a data-engineering story. Most of the coverage did stop there.
But read it sideways and something more interesting shows up. The whole v0.2 update is Google trying to answer one question: once AI agents are writing knowledge, and other AI agents are reading it, how does the reader decide whether to trust what it just found? That is not a data-warehouse problem. That is the problem every brand is now living inside, out on the open web, every time an AI assistant decides whether to cite you or skip you.
So it is worth translating.
The problem OKF is actually solving
Google’s own framing is blunt. A human-authored wiki page comes with an implicit guarantee: a person wrote it, and you can hold them accountable if it is wrong. When an agent generates ten thousand entries overnight, that guarantee is gone. The reader cannot lean on “a human stood behind this” anymore, so it has to judge each entry on explicit signals instead.
Their fix is to make trust something you can read off the top of a file before you commit to reading the whole thing. They landed on five signals, framed as five questions the reader asks:
- What was this created from?
- How much should I trust it?
- Is it still true?
- Is it the current version?
- Was this number produced the way we said it must be?
Here is the thing. Those are the exact five questions an AI answer engine is running on your content right now. It just does not have a tidy metadata block to read them from. It has to infer all five from the page itself.
The five signals, translated for AI search
Provenance. “What was this created from?” OKF adds a field that records the sources a piece of knowledge is built on, along with plain signals like who authored it, how often it gets used, and when it was last touched. Notably, Google refused to add a single credibility “score.” Their reasoning: a score is subjective, goes stale immediately, and does not travel between different readers. Better to expose the raw signals and let each consumer judge.
On the open web, this is your sourcing and your citations. When your content shows its work (named sources, linked primary data, a real author with a real track record), you are handing the machine the provenance it would otherwise have to guess at. When it does not, the machine guesses, and it tends to guess conservatively.
Trust. “How much should I trust it?” OKF splits this into two fields that stay deliberately separate: who generated something, and who independently verified it. From that, a reader can sort entries into unverified, machine-confirmed, or human-reviewed, and filter accordingly. An executive dashboard can be told to only surface human-reviewed numbers.
The lesson for content is the separation itself. Who made a claim and who stands behind it are different facts, and the second one carries more weight. This is EEAT with the marketing language stripped off. Human review, named expertise, and independent confirmation are not soft “quality” ideas. In OKF they are a field you can filter on, which tells you exactly how a machine wants to use them.
Freshness. “Is it still true?” OKF lets a file declare a date after which it should be re-verified before anyone relies on it. They chose a fixed date over a rolling “expires in 90 days” timer on purpose, so staleness is a simple date comparison with no ambiguity.
Your open-web equivalent is genuine recency: real last-updated dates, content that actually changes when the underlying facts change, not a timestamp bump on a page that has not moved since 2023. Answer engines lean hard on freshness, and they are getting better at telling real updates from cosmetic ones.
Lifecycle. “Is it the current version?” OKF marks whether an entry is a draft, the current stable version, or deprecated. A deprecated definition is kept for historical reproducibility but held back from new work.
Most sites have no concept of this. Old pages, superseded guides, and last year’s pricing all sit live with equal standing, and an AI crawler cannot always tell which one you would actually stand behind today. Deprecating, redirecting, and consolidating is not just housekeeping. It is telling the machine which version is canonical.
Attestation. “Was this number produced the way we said it must be?” This is the most interesting one, and the least portable. OKF introduces a way to bind a specific number (say, fiscal-year revenue) to the one sanctioned way of calculating it, plus a mechanical check that confirms the sanctioned calculation is what actually ran. If an agent improvises its own version, the check fails and the number does not get shown.
There is no open-web version of this yet, and that is the honest part of the story. But the intent behind it matters: Google is building infrastructure so that an agent cannot quietly make up a figure and present it as sanctioned. That is the same instinct behind everything in AEO right now. The systems repeating your claims want a way to be sure they are repeating the real ones.
The part worth being honest about
It would be easy to run a headline like “Google just told you the new ranking signals.” It did not, and saying so would be wrong.
OKF is a closed system. It works because everything lives in one bundle where every file can carry structured metadata and every reader agrees to respect it. The open web has none of that. There is no universal trust field on a web page, no shared attestation layer, and no guarantee any given AI system reads the same signals the same way. Schema markup is the closest analog we have, and it is nowhere near this expressive.
So this is not a checklist Google handed you. It is something more useful: a look at how the people building these systems think about machine trust when they get to design it from scratch. And when they design it from scratch, they reach for provenance, independent verification, freshness, clear versioning, and proof that a claim was produced the sanctioned way.
That is not a new game. It is the same game we have been describing as EEAT and citability, now written out in engineering terms by the team building the plumbing.
What to do with this
You do not need OKF to act on it. The move is to make the five signals legible on your own pages, because whether or not a machine has a field to read them from, it is looking for them:
- Show provenance. Real sources, real authors, links to primary data.
- Separate claim from verification. Named expertise and human review, made visible, not buried.
- Prove freshness honestly. Update the substance, not just the date.
- Manage lifecycle. Deprecate, redirect, and consolidate so the canonical version is obvious.
- Make your key numbers checkable. Show the definition and the method behind them, so nothing important reads as an unsourced assertion.
None of that is new advice. What is new is watching Google build the exact same priorities into infrastructure, which is about the strongest signal you can get that these are the things machine readers actually weigh.
The brands that will get cited are not the ones gaming a format. They are the ones whose content answers those five questions before anyone, human or agent, has to ask.
