If you’ve spent any time around AI developers lately, you’ve probably noticed a strange trend. People keep building wikis for AI. And it’s not the typical traditional company wikis. The focus has shifted to AI-specific ones.

Repositories filled with Markdown files. Knowledge folders that agents can read before starting work. Project instruction files that explain how a system works. Documentation systems designed as much for AI as for humans.

Most of these projects were created independently. Yet they all seem to be solving the same problem: giving AI systems reliable context. Google’s newly announced Open Knowledge Format (OKF) is an attempt to bring some structure to that growing ecosystem.

Rather than launching another AI platform, Google is proposing a shared format for organizing knowledge so that different tools, agents, and systems can work with it more cohesively. It’s not so much a brand-new product as it is a common language for AI-ready documentation. That might sound boring at first glance. In practice, it touches one of the biggest challenges facing modern AI systems.

AI Doesn’t Really Have an Intelligence Problem

For the last few years, the conversation around AI has mostly focused on model capabilities. Which model is smartest? Which benchmark score is the highest? Which company released the latest breakthrough?

But once you start building AI tools in the real world, you quickly run into a different issue. The model often isn’t the problem. The information is the bigger concern.

Imagine asking an AI agent a seemingly simple question, such as: How do we calculate weekly active users?

For a human employee, finding the answer might require checking a data warehouse, reviewing an internal metric definition, reading documentation, and asking a coworker for clarification.

An AI agent faces the same challenge. The difference is that most organizations store knowledge across dozens of disconnected systems. Documentation lives in one place. Data definitions live somewhere else. API references live in another repository. Critical information may exist only in a Slack conversation from six months ago.

This is why context engineering has become such a popular topic. The goal isn’t just building better models. It’s building systems that provide models with the information they need to do useful work.

And that’s where the Open Knowledge Format enters the picture.

Why Everyone Suddenly Started Building AI Wikis

Over the last year, developers have started arriving at a surprisingly similar solution. Instead of forcing AI agents to search through the same scattered information over and over again, they create centralized knowledge repositories that agents can reference whenever they need context.

Some people refer to these systems as LLM Wiki. Others call them knowledge vaults, memory systems, agent documentation, or AI operating manuals. The names vary, but the idea is remarkably consistent.

Keep important information in a structured set of files that both humans and AI systems can understand.

One of the clearest examples came from AI researcher Andrej Karpathy, whose Karpathy LLM Wiki concept helped popularize the idea that documentation should be treated as a living resource maintained alongside the work itself.

Anyone who has worked on a growing project has probably seen this happen. The documentation starts out organized, everyone promises to keep it updated, and then real work gets in the way. A few months later, half the links are outdated and nobody is quite sure which document contains the latest version of something.

That’s part of what makes AI-assisted documentation interesting. Models aren’t perfect, but they don’t have the same challenges humans do when it comes to updating references, reorganizing files, or cleaning up repetitive documentation work.

That’s led many teams to build repositories specifically designed for AI consumption. The problem is that everyone is doing it differently.

The Problem With Agent Instruction Files

If you’ve worked with coding assistants recently, you’ve probably encountered files like CLAUDE.md or AGENTS.md. These files act as briefing documents for AI systems.

Before an agent starts writing code or making changes, it reads the file to understand things like:

• Project architecture
• Coding conventions
• Deployment workflows
• Team preferences
• Important constraints

They work surprisingly well. The issue isn’t whether they’re useful. The issue is that there isn’t a shared standard. One team structures its files one way. Another uses different metadata. Another stores everything in a wiki. Another keeps documentation alongside source code.

From a human perspective, these systems often look similar. From a software perspective, they’re all slightly different.

Google’s argument is that the AI industry doesn’t necessarily need another documentation platform. It needs a common format that allows knowledge to move between tools, organizations, and agents more easily.

So What Is the Open Knowledge Format?

The simplest way to understand OKF is to think of it as a shared filing system for AI-ready knowledge.

Imagine a company has information about customers, products, APIs, business metrics, internal processes, and data systems. Today, that information is often stored in different places and structured in different ways.

Google’s Open Knowledge Format proposes a common structure for organizing that knowledge so both humans and AI systems can work with it more easily.

In practical terms, Google released an open specification that says:

• Store knowledge in Markdown files
• Add a small amount of structured metadata using YAML
• Organize files into predictable folders
• Connect related concepts using standard links

That’s essentially what OKF is.

At first glance, the format can feel less exciting than a new model or AI agent. That’s because most of what it uses is already familiar. The files are still Markdown. The documentation still lives in folders. Teams can continue using GitHub, internal repositories, or whatever system they already prefer.

The difference is that Google is trying to standardize some of the patterns that have been emerging across the AI community. Instead of every team creating its own version of an AI-friendly wiki, there would be a common structure that different tools could understand.

Why Google Chose Markdown

One of the most interesting aspects of the announcement is what Google deliberately avoided.

There is:

• No proprietary platform
• No special database
• No required cloud service
• No custom runtime
• No mandatory SDK

One reason OKF feels less intimidating than some new technical standards is that most developers have already seen the ingredients before.

Markdown is everywhere. Documentation repositories, README files, project wikis, personal knowledge bases, it’s one of the most common ways developers organize information. Over the last year, it has also become increasingly common to see teams using markdown for AI agents, storing project context and instructions in files that models can reference while working.

Google seems to be betting that people are far more likely to adopt a standard built on familiar tools than one that requires learning an entirely new system. Instead of asking teams to change how they document things, the format mostly focuses on adding a little more structure to practices that are already widespread.

How an OKF Bundle Is Structured

A typical OKF bundle looks a lot like an organized knowledge repository. 

Imagine a sales team maintaining documentation about its data warehouse. The directory might contain separate sections for:

• Datasets
• Database tables
• Metrics
• Reports
• APIs

Each concept lives in its own Markdown file. The file begins with a small amount of structured metadata, such as:

Below that metadata sits the actual documentation. Because the files are linked together through standard Markdown links, the repository becomes more than a collection of documents. It becomes a navigable graph of relationships.

A metric can link to the tables it depends on. A table can link to the datasets it belongs to. A runbook can link to the systems it references.

From an AI’s perspective, those links create a map of organizational knowledge. Instead of treating every document as an isolated file, an agent can follow relationships between datasets, metrics, APIs, processes, and documentation. That’s a big part of what Google is trying to standardize with OKF.

Why This Matters for AI Agent Memory

One challenge with today’s AI systems is that they often have to rediscover the same information repeatedly. An agent may learn something useful during one task and then lose access to that context later. Developers have responded by building increasingly sophisticated approaches to AI agent memory. Some use vector databases. Some use retrieval systems. Others maintain repositories specifically designed for agent consumption.

OKF doesn’t replace those approaches. Instead, it gives them a common format for storing and exchanging knowledge.

In theory, that means knowledge can persist independently of any single model, framework, or vendor. The memory isn’t tied to the agent. It’s tied to the knowledge itself. In other words, OKF isn’t trying to make models smarter. It’s trying to make knowledge easier for models to access, understand, and reuse.

The Three Ideas Behind OKF

Google’s proposal is built around three principles.

1. Minimal Rules

The specification intentionally requires very little. The goal is interoperability, not strict standardization. Organizations can still decide how they want to structure their content. OKF simply provides enough consistency for different tools to understand the information.

2. Producer and Consumer Independence

One system can create knowledge. Another system can read it. A human-maintained repository could be consumed by an AI agent. A metadata export could be visualized by a completely different tool. The format acts as the shared contract between them.

3. Format, Not Platform

This may be the most important idea in the entire announcement. Google repeatedly emphasizes that OKF is a format rather than a service.

The company is not trying to lock organizations into a specific product. Instead, it is proposing a common language for knowledge that can move between systems. Whether that vision succeeds will depend on adoption, but the intent is clear.

Context Engineering for AI Agents

If you’ve followed discussions around agent development recently, you’ve probably seen growing interest in context engineering for AI agents. The reason is simple. Even extremely capable models struggle when they lack context.

Developers have spent enormous amounts of effort improving prompts, retrieval systems, memory layers, and knowledge management workflows. OKF fits into that broader movement.

Rather than focusing on how agents reason, it focuses on how knowledge is represented. 

Google’s argument is that better context starts with better organization of information. If AI systems can reliably discover, navigate, and understand organizational knowledge, they become significantly more useful, the same shift that’s already powering AI-driven business automation across real-world workflows.

What Google Actually Shipped

The announcement wasn’t just a specification document. Google also released several reference projects designed to demonstrate how OKF can work in practice.

These include:

• An enrichment agent that generates OKF documents from BigQuery datasets
• A visualizer that turns OKF bundles into interactive knowledge graphs
• Sample knowledge bundles built from real-world datasets

Google has also updated its Knowledge Catalog to ingest OKF and make that information available to AI agents. That detail matters because it shows Google is already using the format inside its own ecosystem rather than simply publishing a theoretical proposal.

Will OKF Become a Standard?

It’s too early to know.

Version 0.1 was released only recently, and many organizations are still experimenting with their own approaches to documentation, memory systems, and AI knowledge management.

What makes OKF interesting isn’t necessarily the technology itself. The underlying technologies, Markdown, metadata, linked documents, already exist. What’s new is the attempt to create a shared standard around patterns that have already emerged naturally across the AI community.

The same ideas behind AI-friendly documentation systems are showing up in companies everywhere. Google’s bet is that those patterns are mature enough to benefit from a common format.

Whether that happens remains to be seen. But as AI systems become increasingly dependent on high-quality context, the conversation around knowledge formats is likely just getting started. And that’s ultimately what the Open Knowledge Format is about: creating a portable, vendor-neutral way for humans and AI systems to work from the same body of knowledge.