Open Knowledge and Governance Format

Portable knowledge, with portable trust.

OKGF is a vendor-neutral format for knowledge that carries its own governance. A strict superset of Google Cloud's Open Knowledge Format, it adds the review, provenance, and trust that load-bearing knowledge needs. It builds on the wiki pattern Andrej Karpathy popularised.

Read the spec View on GitHub See how it works →

We set out to make knowledge trustworthy, not to write a standard

A wiki pattern we admired, a gap we kept hitting, and a well-timed release from Google Cloud became OKGF.

Early 2026

Andrej Karpathy's LLM Wiki

We were fans of Andrej Karpathy's LLM Wiki. Rather than re-reading raw documents on every question, an agent compiles what it learns into linked markdown pages that get richer over time. We used it, and we built it into the tools we were working on.

The build

A personal pile of markdown is not enough

The pattern works while the knowledge is only yours. Once it is shared, acted on, or shipped, you need to know more: who approved this, is it authoritative or a draft, where did it come from, can you trust it. So we built our knowledge layer on the pattern and added what it left out: governance.

June 2026

Google Cloud publishes OKF

Then Google Cloud released the Open Knowledge Format. We read it closely. OKF was, in essence, the same idea we had been building, now formalised into a clean, vendor-neutral specification. It stopped at the format and left governance out.

The result: OKGF

We adopted the standard and gave it a spine

Rather than keep our own format, we adopted OKF as the shared foundation and layered our governance back on as a strict superset. Everything OKF gives you, plus the review, provenance, and trust that load-bearing knowledge needs.

Portability is not enough once knowledge is load-bearing

A model is only as good as the context it is given, and that context is scattered across catalogs, wikis, code comments, and people's heads.

The wiki pattern fixed the shape of the problem: compile knowledge into linked markdown an agent can read and maintain, so answers compound instead of being rediscovered. OKF fixed the format: made that portable and vendor-neutral. Both stop before the hard part.

Once knowledge is shared, acted on, or shipped, you have to answer four questions. Who approved this, and for what scope. How good is it. Where did it come from. Can you prove it was not tampered with. If each tool answers those in its own database, the trust lives outside the file and is lost the moment you export it. That is a vendor format again, in a subtler form. OKGF keeps the answers in the file, so trust travels with the knowledge.

OKF, plus five optional governance fields

An OKGF bundle is an OKF bundle: a directory of markdown files with YAML frontmatter, linked into a graph. OKGF adds governance under the reserved x-anthill-* namespace. Every field is optional. A page that omits them is valid, and a tool that does not understand them still reads the bundle, because OKF requires consumers to preserve unknown keys.

---
type: Concept
title: Billing model
description: We bill monthly per seat.
timestamp: '2026-07-02T09:15:00+00:00'
x-anthill-scope: org           # whose knowledge
x-anthill-review: approved     # authoritative, not a draft
x-anthill-tier: gold           # curated and verified
x-anthill-sources:             # provenance
- https://stripe.com/docs/billing
x-anthill-signature: lbTP5Er...  # Ed25519, verifiable out of band
---
# Billing model

We bill monthly per seat.

Field	Values	Meaning
`scope`	personal / team / org	Which plane the page belongs to. The org set is shared and authoritative.
`review`	draft / proposed / approved	Lifecycle state. Authoritative only when approved; promotion passes through proposed.
`tier`	bronze / silver / gold	Quality rating for downstream use, such as training-data selection.
`sources`	list of URIs	Where the knowledge came from.
`signature`	base64 Ed25519	Signs an approved promotion so it can be verified against a published key.

Three principles behind the design

Superset, not fork

Every OKGF bundle is a valid OKF bundle. Governance is additive and namespaced, so an OKGF page round-trips through any OKF-aware tool unchanged.

Optional, but verifiable

Governance fields are optional, and an ungoverned bundle is still conformant. When trust matters, a promotion can be signed and checked anywhere, offline.

Format, not platform

No SDK, no runtime, no registry. A bundle is a tarball you own, hostable in any git repo, and the spec is open for any tool to implement.

An open spec, a validator, and a working implementation

SPEC.md The v0.1 specification: the additive delta over OKF, field by field, with the lifecycle and signature scheme.
CONFORMANCE.md What conformance means and how to claim it, so anyone can check a bundle.
okgf_validate.py A reference validator in Python: structure, governance ranges, and optional signature verification.
examples/ Sample bundles, from an OKF baseline to a fully governed, signed promotion, validated in CI.
AnthillReleased soon The reference implementation. It uses OKGF as its native on-disk format and exports and imports through a review gate.

Read it, implement it, help shape it

The value of a knowledge format comes from how many parties speak it. OKGF is v0.1 and open from day one. Read the spec, validate a bundle, and write a producer or consumer. Contributions are welcome under a simple sign-off.

Connecting to OKF. OKGF is a clean superset of OKF, not a competitor. We are submitting it to the OKF project as a known governance superset and offering the x-anthill-* conventions upstream, so the two stay aligned as OKF evolves.

Stewardship. OKGF is stewarded by the OneHill Foundation. The specification is Apache-2.0. Software that implements it is licensed by its own project.

Read the spec Contribute About OKF →