Open Knowledge Format v0.2 is a structured YAML frontmatter vocabulary that records five families of trust signals so an AI agent can judge whether a knowledge concept is sourced, current, still true, and computed correctly. Rather than collapsing everything into a single credibility score, it captures provenance, verification history, freshness dates, lifecycle status, and runtime attestation hooks so consumers can infer trust from actual evidence.
If you already use Open Knowledge Format (OKF), v0.2 is the missing layer for open knowledge format trust signals: it gives machines the context humans use instinctively, like "where did this number come from" and "is this definition still valid." The sections below walk through the five questions an agent should be able to answer before it acts on your content.
The five questions an agent can now ask about your knowledge
Google Cloud announced OKF v0.2 on July 24, 2026, framing the update around five trust-signal families for agent-maintained knowledge. Search Engine Journal summarized the announcement on July 29, 2026. The goal is not to make knowledge "sound" trustworthy but to make it inspectable.
Each family maps to a concrete question an agent can evaluate:
- Provenance: Where did this come from?
- Lifecycle: Is this the current version?
- Freshness: Is this still true right now?
- Trust: How was it produced, and who confirmed it?
- Attestation: Was this value produced the way it must be produced?
Note: Compatibility is largely preserved:
typeremains the only always-required key, the new trust fields are optional, and custom keys are preserved. However, v0.2 introduces two deliberate migrations:timestampis superseded bygenerated.at, while the body# Citationslist is superseded by frontmattersources. Consumers may fall back to the older forms, so v0.1 bundles remain consumable, but teams should update these fields when adopting v0.2.
1. Where did this come from? (Provenance via sources)
The sources field is the backbone for agent knowledge provenance. It records what the concept was created from, with room for details like author, usage count, and last modified date. For an agent, this is the difference between "a statement" and "a statement with a traceable lineage."
Practically, sources lets you represent multiple upstream inputs (a policy doc, a product spec, a dataset extract) and keep the trail inside the knowledge artifact rather than buried in someone's Slack thread. That matters when an agent has to justify why it answered a question a certain way, a theme also explored in provenance research for agent workflows (IEEE PROV-AGENT, 2025).
2. Is this the current version? (Lifecycle via status)
The status field moves a concept through draft, stable, and deprecated. Lifecycle metadata prevents a common failure mode: deprecated definitions keep circulating because nothing marks them as superseded, and agents keep repeating them with full confidence.
If you are preparing an AI agent-friendly digital presence, lifecycle is the simplest lever for stopping old knowledge from being treated as evergreen. A deprecated concept can still exist for backward references, but consumers can automatically prefer stable ones.
3. Is this still true? (Freshness via stale_after)
The stale_after field answers freshness with a fixed date: after that date, the concept should be rechecked. Search Engine Journal (2026) and the OKF v0.2 spec both emphasize that this is a date comparison problem for consuming systems, not a fuzzy "probably outdated" label.
Choosing a fixed stale_after date rather than a relative time-to-live reduces ambiguity. A scheduler or agent can compare "today" to a stored date without needing to interpret when the content was last fetched, cached, or mirrored across systems (Google Cloud Blog, 2026).
Tip: Use
stale_afterfor facts tied to external cadence: quarterly pricing sheets, plan limits, compliance statements, and published metrics. A concept can be stable in lifecycle terms and still require periodic freshness checks.
Why OKF v0.2 does not include a credibility score
The most opinionated part of okf v0.2 is what it refuses to do: it does not add a single trust or credibility score. It records signals and leaves consumers to infer trust. That stance avoids hard-coding one organization's risk tolerance into the format and keeps the evidence portable across tools.
This is where the Trust family comes in, via generated and verified. generated records how content was produced and when it last changed, for example, extracted from a database snapshot, summarized by a model, or compiled from multiple sources. verified records confirmations by human or machine actors that a definition matches policy or reality, and that confirmation is stored in the bundle (Google Cloud Blog, 2026; OKF v0.2 specification).
| Attribute | Verification | Attestation |
|---|---|---|
| What it confirms | A stored definition or concept matches policy or intended meaning | A specific computed value was produced using the declared method |
| When it happens | Periodically (review, audit, automated checks) | Per call at runtime when a value is requested |
| Is the result stored? | Yes, recorded in verified | No, never stored, only checked at runtime |
| Verification is about definitions in the bundle, attestation is about executions outside the bundle. |
For anyone working in structured knowledge for AI agents, this "signals not score" approach should feel familiar. Search systems already combine many signals rather than publishing a single quality number, and structured data adoption shows how ecosystems evolve around shared vocabularies rather than mandated scoring systems. Vizup's Schema.org Usage Statistics Dataset is a useful parallel: schema markup does not guarantee ranking, but it standardizes machine-readable hints that downstream systems can weigh independently.
The hardest question: was this calculated correctly? (Attested Computation)
Attestation is the most novel part of v0.2 because it targets a different failure mode: a number can be confidently stated, freshly verified as a definition, and still be wrong because it was computed incorrectly. OKF v0.2 introduces a new concept type called attested computation to describe a calculation contract and how a consumer can check that a returned value was produced the required way (Search Engine Journal, 2026).
Two distinctions matter here. First, attestation is separate from verification: verified confirms a definition still matches policy and is stored in the bundle, while attestation confirms a single run produced a value correctly, happens per call at runtime, and is never stored. Second, OKF records the computation and how to check it but never executes anything itself; it is a format for reproducibility, not a compute engine (Google Cloud Blog, 2026).
Operationally, this means your systems can enforce rules like:
- A stale definition can still attest cleanly if the runtime computation followed the declared method, even though the concept is due for recheck.
- A freshly verified definition still needs attestation on each run, because verification does not prove the new output number was generated correctly.
- Attestation policies can be strict for regulated metrics (finance, compliance) and lighter for convenience metrics (engagement rollups).
For a broader conceptual framing of attestation in agent workflows, AgentApproved (2026) describes how runtime attestations differ from audits and certifications, which aligns with OKF's choice to keep attestations ephemeral rather than stored.
What changes for brands and knowledge teams adopting v0.2
Google presents OKF as a format for representing and exchanging knowledge for AI agents, not as a Search ranking feature. As of July 2026, Google has not documented any direct SEO or AI-search ranking benefit from publishing OKF on a public website. The value is operational: it reduces rework, prevents outdated definitions from persisting, and gives agent consumers a consistent basis for deciding when to trust, escalate, or refuse.
This trust layer pairs with the discovery layer. Agentic systems still need to find your resources before they can evaluate them, which is why how AI agents find information matters alongside trust metadata. Discovery without trust yields hallucinated confidence; trust without discovery yields unused knowledge.
Teams already tracking "content signals" in other contexts will recognize the pattern: you are not persuading a machine with prose, you are providing structured evidence it can evaluate. Vizup has covered adjacent thinking in its analysis of content signals, and the same discipline applies here, make provenance explicit, make freshness checkable, and make lifecycle unambiguous.
For implementation planning, treat v0.2 as incremental adoption. Start with status and stale_after where governance pain is highest, then add sources to eliminate tribal knowledge, then add generated and verified to formalize review, and reserve Attested Computation for the metrics that must be correct by construction. If you are mapping this into tooling choices, the broader AI agent stack context helps clarify where OKF sits relative to monitoring, orchestration, and answer quality workflows.
Common misconceptions about OKF v0.2 trust signals
- "If it is verified, it is safe to use forever." Verification is a point-in-time confirmation. Freshness still expires via the stale_after field, and runtime outputs still require attestation when they are computed.
- "Attestation is just another review stamp." Attestation is per execution and not stored. It checks that a specific value was produced correctly, not that a definition is well-written.
- "v0.2 breaks v0.1 bundles." v0.2 adds optional fields and preserves custom keys. A v0.1-style bundle remains valid, but it will look unverified and un-sourced relative to bundles that provide signals.
Key takeaways
- Open Knowledge Format v0.2 adds five families of open knowledge format trust signals in YAML frontmatter: provenance, trust, freshness, lifecycle, and attestation.
- Provenance is recorded in
sources, supporting agent knowledge provenance with traceable origins and change context. - Freshness uses a fixed
stale_afterdate so consumers can do simple comparisons and trigger rechecks. - Lifecycle uses
status(draft,stable,deprecated) to prevent superseded concepts from circulating. - Attested Computation is separate from verification: verification is stored in the bundle, attestation happens per runtime call and is never stored.
Frequently Asked Questions
What is the Open Knowledge Format (OKF)?
OKF is a YAML frontmatter format for packaging machine-readable concepts so AI systems can consume them consistently. For background and examples, see Vizup's primer on Open Knowledge Format (OKF).
Is OKF v0.2 backward compatible with v0.1?
Largely, yes. type remains the only always-required key, and consumers may continue reading legacy v0.1 fields. However, v0.2 supersedes timestamp with generated.at and replaces the body # Citations list with frontmatter sources, so producers should migrate those fields when updating a bundle.
Do I have to use all five trust signals in my knowledge files?
No. Incremental adoption is the norm. Many teams start with status and stale_after, then add sources, then layer in generated and verified, and finally implement attested computation for high-stakes metrics.
What's the difference between attestation and verification in OKF?
Verification (recorded in verified) confirms a stored definition matches policy or intended meaning, and it is stored in the bundle. Attestation (via Attested Computation) confirms a specific runtime calculation produced a value correctly, happens per call, and is never stored. A stale definition can still attest cleanly, and a freshly verified one still needs attestation on each run.
How does OKF relate to Schema.org?
Both are vocabularies that standardize machine-readable signals without guaranteeing outcomes. Schema.org helps machines interpret web content; OKF packages internal or shared knowledge artifacts for agent consumption. Adoption patterns are similar: the value comes from consistent fields that downstream systems can weigh on their own terms.
