Google Cloud Introduces Open Knowledge Format (OKF): A Vendor-Neutral Markdown Spec for Giving AI Agents Curated Context

For makers and artists building with AI, the biggest bottleneck isn’t model power-it’s context. Foundation models can generate code or analyse data, but only if they have the right internal knowledge: table schemas, metric definitions, runbooks, and join paths. That knowledge currently lives scattered across proprietary catalogs, wikis, and the heads of senior engineers. Google Cloud has addressed this by introducing the Open Knowledge Format (OKF), an open specification that turns the LLM-wiki pattern into a portable, interoperable standard.

OKF is designed to be vendor-neutral, serving both agents and humans as the modern context standard. It is not a service or a platform; rather, it is a format that allows wikis written by one producer to be consumed by a different agent without translation.

Open Knowledge Format (OKF)

OKF v0.1 represents knowledge as a directory of markdown files with YAML frontmatter. There is no compression scheme, no new runtime, and no required SDK. A bundle of OKF documents is simply markdown files with YAML frontmatter that render on GitHub, ship as a tarball, and mount on any filesystem. If you have used Obsidian, Notion, or Hugo, the structure will feel familiar; OKF merely formalises the conventions needed to make those patterns interoperable.

The Fragmented Context Problem

In most organisations, model context is overwhelmingly internal knowledge. Today it sits in incompatible silos: metadata catalogs with their own APIs, wikis, shared drives, code comments, and docstrings. Asking an agent ‘How do I compute weekly active users from our event stream?’ requires assembling an answer from scattered, mutually incompatible surfaces. Every vendor offers its own catalog, SDK, and knowledge-graph schema, meaning no knowledge is portable across products or organisations.

The result is duplicated effort. Every agent builder solves the context-assembly problem from scratch, and every catalog vendor reinvents the same data models. Andrej Karpathy articulated the underlying idea in his April 2026 LLM Wiki gist, noting that LLMs do not get bored, do not forget to update cross-references, and can edit many files in one pass. The bookkeeping that makes humans abandon personal wikis is exactly what LLMs handle well.

This pattern keeps reappearing under different names, including Obsidian vaults wired to coding agents, the AGENTS.md and CLAUDE.md convention files, and ‘metadata as code’ repos. Each instance is bespoke, so none of them interoperate. OKF standardises that interoperability layer so agents can do the heavy lifting.

How OKF Works: The Design in One Screen

An OKF bundle is a directory of markdown files representing concepts, tables, datasets, metrics, playbooks, runbooks, or APIs. Each concept is one file, and the file path is its identity. Each concept carries a small YAML front-matter block, then a markdown body for everything else.

The reserved structured fields are type, title, description, resource, tags, and timestamp. Concepts link to each other with normal markdown links. Those links turn the directory into a graph that is richer than file-system parent/child relationships. Bundles can optionally include index.md files for progressive disclosure and log.md files for change history.

Three Principles Behind the Design

• Minimally opinionated: OKF requires exactly one field on every concept: type. Everything else is left to the producer. The spec defines the interoperability surface, not the content model.
• Producer/consumer independence: A human-written bundle can be read by an agent. A pipeline-generated bundle can be browsed in a visualizer. The format is the contract; tooling at each end is swappable.
• Format, not platform: OKF is tied to no cloud, database, model provider, or agent framework. It will never require a proprietary account to read, write, or serve.

Use Cases, With Examples

• Data team metadata-as-code: Export BigQuery table and metric definitions as a bundle. Commit it next to the SQL it describes, and review changes through pull requests.
• Incident runbooks for agents: Store each runbook as a concept. An on-call agent reads index.md, follows cross-links, and resolves the join path it needs.
• Cross-org knowledge exchange: A vendor ships a catalog export as OKF. Your agent consumes it directly, with no integration work.
• Developer-team wiki: Replace a stale Notion or Obsidian space with versioned markdown that an agent keeps current.

How OKF Compares

The distinction from RAG is useful for developers. RAG re-derives knowledge at query time from raw chunks. An OKF bundle stores curated, cross-linked concepts that an agent reads and updates directly.

A Minimal OKF Consumer

OKF is parseable with standard tools. This reads a bundle and builds its link graph. No backend or install is needed to read or serve a bundle. The same files live in version control beside the code they describe.

To implement a basic consumer, you can iterate through the markdown files, extract the YAML frontmatter, and parse markdown links to construct a graph:

import pathlib, re, yaml

def load_bundle(root):
    concepts, links = {}, []
    for path in pathlib.Path(root).rglob("*.md"):
        text = path.read_text()
        meta = {}
        if text.startswith("---"):
            _, fm, body = text.split("---", 2)
            meta = yaml.safe_load(fm) or {}
        else:
            body = text
        concepts[str(path)] = meta            # type, title, tags, etc.
        for target in set(re.findall(r"\]\((/[^)]+\.md)\)", body)):
            links.append((str(path), target))  # markdown cross-links
    return concepts, links

concepts, graph = load_bundle("sales/")

Key Takeaways

• Google’s Open Knowledge Format (OKF) v0.1 formalises the LLM-wiki pattern into a portable, vendor-neutral spec.
• A bundle is just a directory of markdown files with YAML frontmatter-no SDK, runtime, or registry.
• Every concept requires only one field, type; cross-links between files form the knowledge graph.
• Unlike RAG, OKF stores curated, version-controlled concepts that agents read and update directly.