Google's Open Knowledge Format: The Markdown Standard That Could Replace Your Wiki

Last Updated: June 13, 2026

Google just formalized the "digital brain" pattern — plain markdown files that AI agents can read, write, and share. Here's what it means for your business and why it matters more than you think.

What Is the Open Knowledge Format (OKF)?

The Open Knowledge Format (OKF) is an open, vendor-neutral specification for storing organizational knowledge as a directory of markdown files with YAML frontmatter. Announced by Google Cloud on June 12, 2026, OKF gives AI agents a standardized way to read, write, and exchange knowledge without proprietary platforms, SDKs, or lock-in. Each "concept" is a single markdown file. Files interlink with normal markdown links, creating a living wiki that both humans and AI agents can navigate.

The format is deliberately minimal: one required field (type), optional metadata (title, description, resource, tags, timestamp), and a free-form markdown body. That's it. No database, no runtime, no API keys required to read it.

The key insight: OKF formalizes what teams were already doing ad hoc — using markdown + frontmatter as agent-readable knowledge bases — into something interoperable. Wikis written by different producers can now be consumed by different agents without translation.

Read the official spec on GitHub →

Why OKF Matters Now

Organizational knowledge is catastrophically fragmented. The information that AI agents need lives in metadata catalogs with their own APIs, wikis behind login walls, code comments buried in repos, notebook cells, shared drives, and — worst of all — inside the heads of a few senior people.

When an AI agent needs to answer "How do we compute weekly active users from our event stream?", it has to assemble the answer from these scattered, mutually incompatible surfaces. Every agent builder solves the same context-assembly problem from scratch. Every catalog vendor reinvents the same data models. And the knowledge itself is locked behind whichever platform created it.

OKF breaks this pattern by being the lingua franca — a shared format that anyone can produce and anyone can consume. It's the USB-C cable of AI knowledge.

How OKF Works: The 60-Second Tour

An OKF bundle is a directory of markdown files. Each file represents one "concept" — a table, an API endpoint, a metric, a playbook, anything you want to capture.

File Structure

my_knowledge/
├── index.md              # Directory listing (optional)
├── log.md                # Update history (optional)
├── datasets/
│   ├── index.md
│   └── sales.md          # A concept: "Sales Dataset"
└── tables/
    ├── orders.md          # A concept: "Orders Table"
    └── customers.md       # A concept: "Customers Table"

Each File Has Two Parts

YAML frontmatter for structured, queryable metadata:

---
type: BigQuery Table          # REQUIRED — the only mandatory field
title: Customer Orders        # Optional display name
description: One row per completed order
resource: https://console.cloud.google.com/bigquery?p=acme&d=sales&t=orders
tags: [sales, orders, revenue]
timestamp: 2026-05-28T14:30:00Z
---

Markdown body for everything else — schemas, examples, citations, prose:

# Schema

| Column | Type | Description |
|--------|------|-------------|
| order_id | STRING | Globally unique order identifier |
| customer_id | STRING | FK to [customers](/tables/customers.md) |
| total_usd | NUMERIC | Order total in US dollars |

# Joins

Joined with [customers](/tables/customers.md) on `customer_id`.

Concepts Link to Each Other

Normal markdown links create a knowledge graph. The file system hierarchy gives you parent/child relationships. Cross-links add richer connections — joins, dependencies, references. A consumer agent can traverse this graph to build context.

Reserved Filenames

Only two filenames have special meaning:

• index.md — Directory listing for progressive disclosure (let agents see what's available before opening individual files)
• log.md — Chronological update history

Everything else is a concept document.

Three Design Principles That Make OKF Work

1. Minimally Opinionated

OKF requires exactly one field: type. Everything else — what types exist, what other fields to include, what sections the body has — is left to the producer. The spec defines the interoperability surface, not the content model.

This means a data team can use OKF for table schemas while a DevOps team uses it for runbooks, and neither team has to coordinate on taxonomy. Their bundles can coexist in the same agent's context window.

2. Producer/Consumer Independence

This is the killer feature. OKF cleanly separates who writes knowledge from who consumes it:

• A human-authored bundle → consumed by an AI agent
• A pipeline-generated export → browsed by a human in a visualizer
• A bundle written by one LLM → queried by a different LLM

The format is the contract. The tooling at each end is independently swappable. No vendor lock-in, no integration tickets.

3. Format, Not Platform

OKF is not tied to any cloud, database, model provider, or agent framework. It will never require a proprietary account or SDK to read, write, or serve. A bundle of OKF documents is:

• Just markdown — readable in any editor, renderable on GitHub, indexable by any search tool
• Just files — shippable as a tarball, hostable in any git repo, mountable on any filesystem
• Just YAML frontmatter — for the small set of structured fields that need to be queryable

The Karpathy Connection: LLM-Wiki Pattern

OKF didn't appear from nowhere. It formalizes a pattern that AI researcher Andrej Karpathy articulated in his widely-shared LLM Wiki gist:

"LLMs don't get bored, don't forget to update a cross-reference, and can touch 15 files in one pass. The bookkeeping that causes humans to abandon personal wikis is exactly what LLMs are good at."

The insight: instead of using AI to search raw documents over and over (RAG), have the AI incrementally build and maintain a persistent wiki. The knowledge compiles once and stays current. Every new source enriches the existing graph. Cross-references are maintained automatically. Contradictions get flagged.

Teams were already doing this — Obsidian vaults wired to coding agents, CLAUDE.md / AGENTS.md convention files, repos full of index.md artifacts. But each instance was bespoke. OKF makes them interoperable.

Could OKF Replace Notion or Obsidian?

This is the question everyone is asking. The honest answer: yes for teams, not yet for individuals.

Where OKF Wins Over Traditional Wikis

Version control is built in. Your knowledge base lives in git. Every change is a commit with authorship, timestamp, and diff. Notion and Obsidian have history features, but git is the universal standard that every developer already knows.

AI agents can read AND write natively. Notion has an API, but it requires authentication, rate-limit management, and SDK knowledge. Obsidian plugins exist but are fragile. OKF? An agent just writes a markdown file. No API, no authentication, no SDK. The file system IS the API.

Zero platform lock-in. Your Notion workspace lives in Notion. Your Obsidian vault lives on your machine with Obsidian-specific plugins. An OKF bundle lives in any git repository, on any filesystem, readable by any tool that can parse markdown. You can switch consumers (viewers, search indexes, agents) without migrating your content.

Composable across organizations. You can't merge two Notion workspaces. You can't easily share an Obsidian vault between teams at different companies. OKF bundles can be shared as tarballs, published as git repos, or mounted as subdirectories. A vendor can ship an OKF bundle documenting their API. Your team can import it directly into your knowledge graph.

Where Traditional Tools Still Win

Rich editing experience. Notion's block editor, database views, and inline embeds are genuinely better than raw markdown for non-technical users. Obsidian's graph view, backlinks panel, and plugin ecosystem create a richer browsing experience.

Non-technical accessibility. OKF assumes comfort with markdown, git, and file systems. For engineering teams, this is table stakes. For marketing, HR, or operations teams, Notion's WYSIWYG editor remains more accessible.

Ecosystem maturity. OKF launched yesterday. Notion has a decade of integrations, templates, and community. Obsidian has thousands of plugins. OKF has a spec, three sample bundles, and a reference visualizer.

The Realistic Path

For engineering and data teams already living in git and markdown, OKF could replace internal wikis within months. For broader organizations, it becomes the backend format that AI agents use — while humans continue interacting through whatever frontend they prefer. The format is flexible enough to support both.

Practical Use Cases for Australian Businesses

Data Teams: Automated Table Documentation

Point an OKF enrichment agent at your BigQuery or Snowflake warehouse. It walks every table and view, drafts a concept document for each, then runs a second pass to add join paths, schemas, and business context. Your data dictionary maintains itself.

Engineering Teams: Self-Updating Runbooks

When an incident occurs, your AI agent reads the relevant OKF playbooks, follows the runbook steps, and updates the document with what it learned. Next time the same alert fires, the runbook is already enriched. Knowledge compounds instead of evaporating in Slack threads.

AI Consultancies: Portable Knowledge Bundles

For businesses like ours at Flowtivity, OKF means we can ship knowledge bundles alongside the AI systems we build for clients. Instead of documenting a custom automation in a Notion page that the client will forget exists, the documentation lives as OKF markdown inside the client's repo — queryable by their future AI agents, version-controlled, and portable.

Compliance and Audit Trails

Every OKF bundle has optional log.md files at any directory level. Changes are tracked in ISO 8601 format. For regulated industries, this means your knowledge base is audit-ready by default — no separate compliance tooling needed.

How to Get Started with OKF Today

1. Read the Spec (It's Short)

The full OKF v0.1 specification fits on a single page. It's the most readable technical spec we've seen in years.

2. Create Your First Bundle

Create a directory. Add markdown files with YAML frontmatter. The only required field is type. You're already OKF-conformant.

3. Wire It to Your AI Agent

If you're using Claude Code, OpenClaw, or any agent that can read files, point it at your OKF bundle directory. The agent can read concepts, follow cross-links, and even write new concepts as it learns.

4. Try the Reference Tools

Google shipped three sample bundles (GA4 e-commerce, Stack Overflow, Bitcoin datasets), an enrichment agent for BigQuery, and a static HTML visualizer that turns any bundle into an interactive graph view — no backend required.

5. Host It Anywhere

Push your bundle to a GitHub repo. Mount it on any filesystem. Ship it as a tarball. There's no platform to sign up for and no account to create.

What OKF Means for the AI Agent Ecosystem

The biggest impact of OKF isn't the format itself — it's the standardization. Here's what changes:

Context assembly becomes a solved problem. Instead of every agent builder writing custom integrations for Notion, Confluence, Jira, and every other knowledge source, they write one OKF consumer. Producers export to OKF once; every agent benefits.

Knowledge becomes portable between organizations. A vendor can publish an OKF bundle documenting their API. A consultant can deliver an OKF bundle as part of a project. Teams can merge, fork, and share knowledge bases the same way they share code.

The wiki pattern compounds. Karpathy's insight was that LLMs make wiki maintenance viable because they handle the bookkeeping humans abandon. OKF makes that pattern interoperable. Every team that adopts it makes every other team's agents smarter.

It pushes Notion, Obsidian, and Confluence toward becoming OKF-compatible. If OKF gains traction, expect these platforms to add OKF import/export. The format pressure benefits everyone, even teams that never directly use OKF.

The Bottom Line

Google's Open Knowledge Format is the most important infrastructure announcement for AI agents this year. Not because the technology is complex — it's deliberately simple — but because it standardizes the unsexy plumbing that makes AI agents actually useful in production.

If your team is building AI systems, start experimenting with OKF now. The format is five minutes to learn, free to use, and already backed by Google Cloud's Knowledge Catalog. The first-mover advantage isn't technical — it's cultural. Teams that start building living knowledge bases today will have a compounding head start over those that wait.

The future of organizational knowledge isn't a smarter search engine or a better wiki tool. It's a directory of markdown files that both you and your AI agents can read, write, and grow together.

FAQ

What is the Open Knowledge Format (OKF)?

The Open Knowledge Format is an open specification from Google Cloud that represents organizational knowledge as a directory of markdown files with YAML frontmatter. Each file represents one concept, files interlink with standard markdown links, and the only required field is type. It launched June 12, 2026 as OKF v0.1.

Can OKF replace Notion or Obsidian?

For engineering and data teams already comfortable with markdown and git, OKF can replace traditional wiki tools for internal documentation. For non-technical teams, traditional tools remain more accessible. The most likely outcome is OKF as the backend format with traditional tools as the frontend interface.

How is OKF different from regular markdown files?

OKF adds a minimal structure: a required type field in frontmatter, conventions for cross-linking between files, reserved filenames (index.md for directory listings, log.md for change history), and conformance criteria. This small amount of standardization enables interoperability between different producers and consumers.

Is the Open Knowledge Format free to use?

Yes. OKF is an open specification published under Apache 2.0 license. There is no SDK to install, no account to create, and no platform lock-in. The format consists of markdown files that any text editor can read and any git repository can host.

What problems does OKF solve for AI agents?

OKF solves the "context assembly problem" — the challenge of gathering relevant information from fragmented sources before an AI agent can do its work. By standardizing on one format, agents can consume knowledge from any OKF producer without custom integrations, and producers can write knowledge once for any OKF-consuming agent.