Google’s Open Knowledge Format: The Agent SEO Playbook Changed

Reading time: 6 min

Key takeaways

• OKF standardizes organizational knowledge for AI agents using plain Markdown files with YAML headers—no SDK, no proprietary runtime needed.
• This shifts the game from being found by search engines to making your knowledge actionable by AI agents. GEO is no longer about citations—it’s about agent workflows.
• Google has already baked OKF into its Knowledge Catalog, giving the format production credibility. Early tests show real agent-driven knowledge graphs are viable today.

Google dropped a knowledge standard. Nobody talks about this part.

Google released the Open Knowledge Format (OKF) specification on June 12, 2026. I’ve seen this play out before—open standards that start quiet and rewrite industries three years later. This one deserves your attention now.

The OKF is a directory of Markdown files with YAML frontmatter. No new runtime, no proprietary SDK, no cloud lock-in. Any agent can read it. Any human can produce it. Here’s what actually happened: Google formalized the “LLM-Wiki pattern” Andrej Karpathy described into a spec that turns any folder of .md files into a living knowledge graph for AI agents.

Let me show you the data. Google immediately updated its Knowledge Catalog to ingest OKF and serve it to its own agents. That’s not a beta—that’s production.

The real problem OKF solves: fragmented knowledge

Every organization I’ve worked with—from scrappy startups in Sacramento to Bay Area scale-ups—has the same mess. Knowledge sits in incompatible systems:

• Metadata catalogs with their own APIs
• Internal wikis
• Code comments
• Shared drives packed with outdated docs
• Tacit knowledge inside three senior engineers’ heads

When an agent needs to answer “How do we calculate weekly active users from our event stream?”, it has to assemble context from all those incompatible platforms. Every vendor reinvents the same data model. Knowledge stays trapped in the surface that created it.

Slow down. Think. Your competitors are building the same agent foundation from scratch, bespoke, with zero interoperability. I’ve seen this play out before with websites in the late 90s—everyone building their own HTML from scratch, no standards, no reuse.

What OKF actually looks like: minimal by design

An OKF bundle is a directory of Markdown files. Each file represents one concept—a database table, a business metric, a runbook, a deprecated API. The file path is the concept’s identity. Simple.

Here’s a minimal document from the official spec:

---
type: metric
title: Weekly Active Users (WAU)
description: The number of unique users who performed at least one meaningful action in the last 7 calendar days.
tags: [engagement, active-users, weekly]
---

WAU is calculated from the user_events table by filtering events with `event_type = 'meaningful_action'` and deduplicating by `user_id` over a rolling 7-day window.

See: [user_events.md](user_events.md), [event_types.md](event_types.md)

Only the type field is required. Everything else is up to you. Concepts link via standard Markdown links, turning the directory into a relationship graph. Bundles can include index.md for hierarchical navigation and log.md for chronological change history.

This isn’t a take—it’s a pattern. The design has three principles:

• Minimalism: One required field. The spec defines the interoperability surface, not your content model.
• Producer/consumer independence: A human-written bundle works for an AI agent. A pipeline-generated bundle works in a visualizer. A LLM-synthesized bundle gets queried by another LLM.
• Format, not platform: No cloud, no database, no model vendor, no agent framework required. Google published it open source because value comes from adoption, not ownership.

The LLM-Wiki pattern gets a formal home

The OKF formalizes something that’s been emerging in the agent developer community—the pattern Karpathy codified in a GitHub gist. The core idea: instead of having agents re-search the same documents for the same facts, give them a shared Markdown library that compounds in utility over time.

Karpathy’s insight still cuts deep: “LLMs don’t get bored, they don’t forget to update a cross-reference, and they can edit fifteen files in a single pass.” The maintenance burden that kills human wikis is exactly what LLMs are good at.

I’ve seen implementations everywhere: Obsidian vaults wired to coding agents, AGENTS.md file conventions, CLAUDE.md directives, index.md repos agents check before doing real work. Each is custom-built. The OKF brings the standardization that lets these wikis cooperate, not just coexist.

What Google shipped alongside the spec

Google didn’t drop a spec and walk away. They published:

• An enrichment agent that crawls a BigQuery dataset, generates an OKF document per table and view, then runs a second LLM pass to enrich each concept with citations, schemas, and join paths.
• A static HTML viewer that transforms any OKF bundle into an interactive graph visualization—no backend, no install, data stays client-side.
• Three example bundles built from public BigQuery datasets (GA4 e-commerce, Stack Overflow, Bitcoin), already committed to the repo.

The Knowledge Catalog update means OKF is in production Google agents right now. That’s real credibility. Not a whitepaper—a running system.

What this means for SEO and GEO: the shift from being found to being usable

Marie Haynes, a respected SEO consultant, caught the core implication: “We are moving from a job of being found by search engines to a job of making an organization’s knowledge usable by agents to get things done.”

This shift is deeper than most practitioners realize. Until now, GEO meant optimizing content to get quoted by generative models. With OKF, the question becomes: how do you structure your organization’s knowledge so an agent can navigate it, reason over it, and act with it?

Haynes points out that building a quality OKF bundle requires real work: deeply understanding a domain’s concepts, documenting processes, mapping relationships across data. It’s not converting web pages to Markdown. It’s building the structured brain of an organization.

She also flags an emerging opportunity: selling OKF bundles of expert knowledge. A lawyer, accountant, or SEO consultant could package proprietary processes as an OKF bundle for other organizations to integrate into their own knowledge systems. Let me show you the data: early tools already exist. Suganthan Mohanadasan built a web-page-to-OKF converter. But Haynes emphasizes the real value comes from bespoke bundles, not mechanical transplants.

Early tests prove it works today

Haynes documented her first OKF bundle build from her own traffic-drop assessments. She extracted key concepts across multiple documents, stored them as separate Markdown files, visualized them as a graph where nodes are concepts and edges are relationships, then queried the bundle via Gemini 2.0 Flash.

Her test run only spanned three training documents—but the principle is validated. A _functional OKF knowledge base_ is buildable right now with accessible tools. This isn’t a distant tech preview. I’ve built this exact pattern for teams that needed to share project context across tools. OKF makes it standardized.

This is v0.1. The hard work is ahead.

Google explicitly frames OKF v0.1 as a starting point. The spec fits on a single page. It will evolve as producers and consumers emerge and as the community collectively learns which knowledge representations agents actually need.

The open source release from day one is deliberate: the value of a knowledge format comes from how many parties adopt it. The playbook changed. Again. Here’s what you can do today:

• Read the spec. It’s short.
• Write a producer for your own data sources.
• Build a consumer—viewer, search index, agent—for bundles.
• Test the reference implementation on your own data.
• Contribute to the GitHub repo.

This isn’t a take—it’s a pattern. And patterns compound. Start now.

Source: Introducing the Open Knowledge Format (Google Cloud), June 12, 2026