What is Open Knowledge Format (OKF)? A Knowledge Format that AI Agents Can Read and Take Away

AI models are becoming increasingly adept at writing code, organizing documents, and analyzing data, but they still face a very real limitation: without the right background knowledge, it's easy for them to give answers that sound great but are inaccurate.

In an enterprise, truly important context is often scattered across many places. The meaning of a data table's fields is in the data catalog, business metrics definitions are in presentations, incident response procedures are in the Wiki, and senior engineers hold a bunch of undocumented experience in their heads. When an AI agent needs to complete a task, relying on the model alone is usually not enough; it needs to be able to reliably read this organizational knowledge.

Open Knowledge Format (OKF) is an open specification introduced by Google Cloud on June 13, 2026. Its goal is to use a simple, portable, and vendor-agnostic way to organize the knowledge context that AI agents need.

If you think of a large language model as a very smart new colleague, OKF is like an organized company knowledge handbook: not tied to a specific system, readable by humans, and readable by AI.

The Bottom Line

OKF is an open format that represents knowledge using Markdown files + YAML frontmatter, allowing the context of data tables, metrics, APIs, operational manuals, and documents to be exchanged across different tools, teams, and AI agents.

What Problem Does It Solve?

Many AI applications today are not bottlenecked by model capabilities, but by "context acquisition".

For example, if you ask an internal AI agent: "How do we calculate weekly active users?" It might need to know simultaneously:

• Which event data table is the official source.
• Which events to include and which test events to exclude.
• How to merge user IDs.
• Whether the definition of this metric has been changed in the past.
• Where to find relevant SQL examples.

This information is often not in the same system. Some are in the data catalog, some in Google Docs, some in Notion, some hidden in code comments, and some only exist in team habits.

OKF is not trying to "build another knowledge service", but rather to define a format that everyone can understand first. As long as different systems can output or read OKF, knowledge is less likely to be locked in a single platform.

How Does OKF Work?

The core design of OKF v0.1 is very simple: a knowledge package is just a folder containing many Markdown files. Each Markdown file represents a "concept".

This concept could be:

• A BigQuery data table.
• A dataset.
• A business metric.
• An API.
• An incident response manual.
• A product or system background description.

The folder structure itself is the way knowledge is organized. For example:

sales/
├── index.md
├── datasets/
│   └── orders_db.md
├── tables/
│   ├── orders.md
│   └── customers.md
└── metrics/
    └── weekly_active_users.md

Above each concept file, there is a small block of YAML frontmatter used to store fields that are easier for machines to query. Below that is standard Markdown content, allowing both humans and AI to read.

---
type: BigQuery Table
title: Orders
description: One row per completed customer order.
resource: https://console.cloud.google.com/bigquery
tags: [sales, revenue]
timestamp: 2026-05-28T14:30:00Z
---

# Schema

| Column | Type | Description |
|---|---|---|
| `order_id` | STRING | Unique order identifier |
| `customer_id` | STRING | Corresponds to user in the customers table |

# Joins

Can be joined using `customer_id` and [customers](/tables/customers.md).

This design is deliberately uncomplicated. It's not a new database, nor a new cloud service, but a combination of already ubiquitous elements like Markdown, folders, and YAML frontmatter into a set of conventions.

Core Features

1. Readable by Both Humans and AI

Because OKF uses Markdown, engineers can open it directly in an editor or read it on GitHub. AI agents can also load the file content into context without needing to integrate with a specific SDK first.

This is very important. If enterprise knowledge can only be accessed through a closed platform, AI agents must write a separate integration for each platform. OKF reduces the unit of exchange down to a "file".

2. Retains Queryable Fields Using YAML Frontmatter

While completely free-form articles are easy to read, they are not necessarily easy for machines to filter. OKF uses frontmatter to store a small amount of structured fields, such as type, title, description, resource, tags, and timestamp.

These fields allow tools to quickly know: is this a data table, a metric, or an operational manual? As for the finer details, they are still kept in the Markdown body.

3. Knowledge Versioning with Git

Because an OKF knowledge package is essentially a folder, it can be put into Git. This means knowledge can be reviewed via pull requests, its revision history can be viewed, and changes to metric definitions can be tracked to specific commits.

For data teams, this approaches the concept of "metadata as code": managing data knowledge like code, rather than placing it in document platforms where version differences are invisible.

4. Not Tied to Specific Clouds, Models, or Agent Frameworks

OKF's official positioning is as a format, not a platform. It doesn't require using Google Cloud, nor does it require a specific model, a specific agent framework, or a specific database.

This makes it more like an exchange language. The producer can be a data catalog export tool, a document crawling pipeline, or documents written by engineers; the consumer can be a search index, a graph visualization tool, an AI agent, or a static documentation site.

5. Turns Knowledge into a Graph via Links

OKF relies on more than just folder hierarchies. Concept files can point to each other using standard Markdown links. For instance, a metric can link to a data table, SQL examples, and business definitions.

This transforms knowledge from a "tree-like folder structure" to something closer to a "relationship web". When an AI agent needs to track down an answer, it's easier to follow the links to find relevant context.

How Is It Different from Regular Wikis, Notion, or Data Catalogs?

OKF isn't meant to replace all Wikis or data catalogs. A more reasonable perspective is: it can serve as an intermediate format between these systems.

For example, a data catalog can output OKF, a document system can append business descriptions, and then an AI agent reads the organized OKF knowledge package.

What Do Non-Engineering Background Professionals Need to Know?

For managers, content creators, or product teams, the point of OKF isn't Markdown or YAML itself, but rather that "AI must have a commonly readable knowledge foundation."

When many enterprises adopt AI, they first ask which model, which chatbot, or which agent framework to choose. But what truly affects quality is often whether organizational knowledge is well-organized.

If there's no consistent internal definition for "customer churn rate," "active users," or "official data sources," AI will only amplify the chaos. What makes OKF noteworthy is that it turns this context into a collection of documents that can be version-controlled, moved around, and read by AI.

Who Is It For?

• Data Teams: Want to organize data tables, fields, metrics, query examples, and source descriptions into a trackable format.
• AI Agent Developers: Need to build a readable, updatable, and portable knowledge base for agents.
• Platform and Tool Developers: Want their data catalogs, document systems, or search tools to support an open exchange format.
• Enterprises Prioritizing Knowledge Governance: Want to put important definitions and operational processes under version control, rather than scattered across different document platforms.

Who Might It Not Be For?

• People Who Only Need Personal Notes: If it's just personal memos, Obsidian, Notion, or regular Markdown notes are sufficient.
• Those Expecting a Complete Knowledge Management Platform: OKF is a format, not a full product with permissions, search, approval workflows, and visual interfaces.
• Teams Without the Willingness to Organize Knowledge: A format can only lower exchange costs; it cannot automatically decide for the organization which knowledge is the correct version.

How to Get Started Now?

Google Cloud has currently published the OKF v0.1 specification, GitHub repository, reference implementations, and example knowledge packages. Those who want to try it can start from three directions:

1. Read the OKF v0.1 specification to understand the required fields and folder conventions.
2. Choose a small scope for a pilot run, such as organizing just one dataset or a set of commonly used metrics.
3. Put the OKF knowledge package into Git, allowing the team to maintain content via pull requests.

For data teams, you can start with the questions most frequently asked by AI or colleagues, such as "How do I join this table?", "How is this metric calculated?", and "Which field is the official source?"

Our Observations

OKF is noteworthy because it tackles a real problem AI agents will increasingly face: the models themselves are getting stronger, but enterprise context remains fragmented, closed, and hard to move.

Its design is also very pragmatic. It doesn't create another massive platform, but chooses foundational elements like Markdown, YAML, folders, and Git that are already supported by a vast array of tools. This keeps the barrier to entry relatively low and mitigates the risk of vendor lock-in.

However, OKF v0.1 is still an early specification. Whether it can become a widely adopted standard depends on whether more data catalogs, AI agent frameworks, and enterprise documentation tools are willing to support it. In the short term, it is best suited for initial use in data teams and AI agent projects as a lightweight, version-controllable knowledge exchange layer.

Sources

• Google Cloud Blog: Introducing the Open Knowledge Format
• OKF v0.1 Specification: https://github.com/GoogleCloudPlatform/knowledge-catalog/blob/main/okf/SPEC.md
• OKF GitHub Repository: https://github.com/GoogleCloudPlatform/knowledge-catalog/tree/main/okf
• Date Accessed: 2026-06-21