Core idea: For high-precision enterprise domains, agent performance depends as much on knowledge representation as it does on model capability. OKF points to a more structured, auditable way to package domain knowledge for AI agents.
Google quietly dropped something in June 2026 that has the potential to change the way AI agents access content. It is a file format called Open Knowledge Format (OKF). OKF represents knowledge as a directory of markdown files, cross-linked like a wiki, and readable directly by AI agents as context.
A file format is not usually headline news when frontier labs are shipping new models every week. But this one is focused on a very practical problem: helping agents read, traverse, and reason over content more effectively. I spent time understanding the concept and building a proof of concept with it, and I think OKF is solving a key problem that enterprise AI is still grappling with.
Enterprise Knowledge Problem
When organizations try to deploy AI agents on top of internal knowledge such as clinical guidelines, underwriting rules, and compliance policies, they hit the same wall. The knowledge exists, but it is in the wrong shape.
Most enterprise knowledge still lives in PDFs, SharePoint wikis, Confluence pages, and documents written for humans to read linearly. Agents need something different. They need context they can traverse.
The usual answer is RAG: chunk the documents, embed them, and retrieve relevant fragments at query time. RAG works well up to a point. The problem is that retrieval is noisy. A drug contraindication buried deep inside a clinical guideline does not automatically surface when an agent is reasoning about kidney function unless that connection has been explicitly modeled.
OKF takes a different approach. Instead of indexing documents at query time, you curate knowledge upfront. Each concept gets its own markdown file. Each file links explicitly to related concepts. The agent reads the bundle directly with no retrieval pipeline, no embedding index, and no chunking strategy. Just a graph of curated knowledge the model can traverse.
The tradeoff is real. Someone has to do the curation work. When guidelines update, the bundle needs updating. But for domains where precision matters more than breadth, that is often the right tradeoff.
What OKF Actually Is
OKF is quite simple. A bundle is a directory of markdown files. Each file has YAML frontmatter such as type, title, description, tags, timestamp, and source, followed by a markdown body with prose and cross-links to other concepts.
A root index enables progressive disclosure. A change log tracks updates. There is no proprietary SDK, no database, and no runtime dependency. Any agent that can read text can consume it.
What makes OKF interesting is not the format itself. It is the design intent. OKF is built on the premise that curated, versioned, cross-linked knowledge is more useful to AI agents than retrieved fragments of unstructured documents.
The knowledge graph it produces is genuinely different from what RAG retrieves. When an agent reads an OKF bundle, it does not simply find relevant passages. It sees a connected web of concepts where relationships are explicit. That matters for multi-hop reasoning.
For example, answering “What is the first-line treatment for a Type 2 Diabetes patient with early chronic kidney disease?” is not just a retrieval problem. It is a traversal problem. The agent needs to connect a condition, medication, lab value, comorbidity, and safety rule. OKF makes those connections primary elements of the knowledge base.
Building an OKF Knowledge Graph: A Practical Approach
To explore the potential of OKF, I selected a domain with three characteristics: a rich set of interconnected concepts, authoritative source material, and real-world decision-making complexity. Type 2 Diabetes proved to be an ideal candidate because treatment pathways, clinical assessments, medications, comorbidities, and monitoring protocols are deeply connected rather than existing as isolated pieces of information.
The process began by identifying the primary knowledge sources and converting them into clean, structured markdown. Rather than treating the content as a collection of documents, the goal was to decompose it into discrete concepts that could stand on their own while maintaining explicit relationships with other concepts in the domain.
Each concept was represented as an individual OKF file containing metadata, descriptive content, and links to related concepts. These concepts were organized into logical categories such as conditions, assessments, monitoring protocols, treatments, medications, and comorbidities. The result was not a document repository but a connected knowledge graph where relationships became first-class elements of the knowledge base.
One of the most important lessons was that knowledge architecture matters as much as content. Concepts should be created incrementally and systematically, ensuring that core entities exist before dependent concepts reference them. Cross-link validation becomes critical because the value of the knowledge graph comes from the integrity of the relationships it captures.
Once the knowledge bundle is established, it can support multiple experiences. The same OKF bundle can be visualized as a graph, explored as structured documentation, or provided directly to an AI agent as contextual knowledge. Because relationships between concepts are explicitly encoded, agents can traverse the knowledge graph to perform multi-hop reasoning rather than relying solely on retrieval from disconnected document fragments.
This approach illustrates a broader pattern that can be applied across enterprise domains. Clinical guidelines, compliance policies, underwriting rules, product specifications, operational runbooks, and business processes can all be transformed from static documents into curated, interconnected knowledge assets. The result is a version-controlled knowledge foundation that is more transparent, auditable, and agent-friendly than traditional document-centric approaches.
What the Approach Shows
The most useful test cases are deliberately multi-hop. For example, “What is the first-line treatment for a Type 2 Diabetes patient with early chronic kidney disease?” requires an agent to traverse from the condition to the medication algorithm, then to metformin, then to kidney function constraints, and finally to renal and cardiovascular considerations.
Another example is “Which medications reduce cardiovascular risk beyond glucose control?” This requires the agent to move across medication classes, cardiovascular risk concepts, and evidence around GLP-1 and SGLT2 therapies.
The important point is not that the model can answer these questions from memory. The point is that the relevant relationships are explicitly present in the knowledge bundle. The answer becomes auditable because a reviewer can trace the reasoning path through the concepts and links.
The Honest Drawbacks
Maintenance is real work. Healthcare research groups such as American Diabetes Association updates its guidelines annually. When the next version arrives, someone has to identify what changed, update the affected concept files, and re-audit the cross-links. For organizations without a clear owner for knowledge curation, OKF bundles can go stale fast.
Scope decisions require judgment. A small proof of concept may cover a few dozen concepts. A production knowledge base may need hundreds. Deciding what deserves its own concept file and what should be folded into another concept requires domain expertise that cannot be automated away.
The format is still early. Mature tooling, validation libraries, bundle registries, and standardized update protocols are still emerging. That is the cost of being early, but it is also where the opportunity is.
Where This Gets Interesting
Portable capability bundles: A health plan could package prior authorization logic as an OKF bundle, including conditions, coverage rules, clinical criteria, drug tiers, and related policies. A provider system could consume the bundle directly without a custom API integration. The payer ships knowledge, not just an interface.
Living guideline distribution: Professional bodies currently publish detailed documents. In the future, they could also publish versioned OKF bundles. AI agents in healthcare systems could consume the same authoritative clinical knowledge, with updates managed through version control rather than document republication alone.
Enterprise knowledge as version-controlled infrastructure: Product specifications, underwriting criteria, compliance policies, and operational runbooks could be curated into OKF bundles, versioned in Git, reviewed like code, and consumed by any agent that needs them. The AI does not just query a database. It reads a knowledge graph maintained with the same discipline as software.
The Broader Point
I have watched organizations build AI agents that confidently traverse internal knowledge and produce fluent, plausible, wrong answers. The failure mode is not always the model. Often, it is the knowledge representation.
Unstructured documents do not give agents the connected context they need for multi-hop reasoning. OKF is not a complete solution. It requires curation discipline that most organizations are not yet set up for, and the tooling is still sparse. But the underlying idea feels right: curated, cross-linked, version-controlled knowledge can be more effective than retrieved fragments of documents when the work requires precision, reasoning, and auditability.
