Open Knowledge Format

by Google Cloud

Vendor-neutral open specification for organizing and sharing curated knowledge with AI agents. Plain markdown files with YAML frontmatter, enabling portable, versionable, human-readable knowledge bases. Announced June 2026.

Overview

Open Knowledge Format (OKF) is Google’s response to a critical problem in agentic AI: knowledge is scattered across incompatible silos (proprietary catalogs, isolated wikis, code comments, individual minds), and every new AI agent must reinvent context-assembly from scratch.

OKF formalizes the “LLM-wiki pattern” into a portable, vendor-neutral standard that treats organizational knowledge like code—versionable, reviewable, auditable, and shareable across systems and organizations.

Problem It Solves

Fragmented Context Landscape

Organizations scatter knowledge across incompatible systems with no standardized way to share with AI agents.

Vendor Lock-in

Knowledge becomes trapped behind proprietary platforms; migrating to new tools means abandoning historical context.

Repeated Problem-Solving

Every new agentic system requires rebuilding the context-assembly layer from scratch.

Portability Gap

No standardized format for knowledge to survive tool migrations or work across vendors and frameworks.

Core Specification

Structure

Plain markdown files organized in directories with optional YAML frontmatter.

knowledge-base/  
├── concepts/  
│   ├── llm.md  
│   ├── rag.md  
│   └── agents.md  
├── organizations/  
│   ├── anthropic.md  
│   └── openai.md  
└── projects/  
    ├── project-alpha.md  
    └── project-beta.md  

Frontmatter Fields

• type (required): concept, organization, product, project, etc.
• title (required): Human-readable title
• published: Publication date
• aliases: Search terms for agent discovery
• Custom fields: Any domain-specific metadata

Content Format

• Plain markdown (human-readable)
• Standard markdown links for knowledge graph connections
• No complex schemas or proprietary formats
• Git-versionable and code-reviewable

Key Features

Simplicity

• Zero SDK requirement
• No special tooling, runtimes, or databases
• Works in any markdown editor
• Renderizable on GitHub immediately

Git-Native

• Version controlled like software
• Commit history as organizational memory
• Code-reviewable knowledge changes
• Diff-able history of evolving concepts

Portability

• Same bundle works across LLM providers
• No vendor or tool lock-in
• Can migrate between frameworks without data loss
• Portable knowledge survives organizational changes

Interoperability

• Minimal opinionation: format defines interoperability surface only
• Producers and consumers independent
• Works with any LLM or agent framework
• Open Apache 2.0 license on GitHub

Knowledge Graph

• Markdown links create concept connections
• Agents can navigate reasoning paths
• Persistent relationships between ideas
• Updatable by agents (create new files, update links)

Dual Audience

• Human-readable markdown (for organizational teams)
• Machine-readable YAML/structure (for AI agents)
• No lossy conversion between formats

How It Differs from Alternatives

Aspect	OKF	JSON-LD/Schema.org	RAG Systems
Format	Markdown + YAML	JSON semantic markup	Unstructured documents
Audience	AI agents + humans	Web search/semantic web	Dynamic retrieval only
Readability	Human-first	Machine-first	N/A
Tooling	Zero SDK needed	Requires validation	Vector DB infrastructure
Structure	Curated, persistent	Semantic annotations	Retrieved dynamically
Agent Capability	Read AND update	Passive annotation	Retrieves, doesn’t persist
Use Case	Organizational memory	Web interoperability	Unstructured knowledge retrieval

OKF vs. RAG

• OKF: Persistent, curated knowledge; agents reason over and update; no embedding pipelines needed
• RAG: Dynamic retrieval of unstructured documents; requires vector DBs and retrieval-reranking; documents read-only to agents

OKF v0.2: Enterprise-Grade Trust & Compliance

What Changed from v0.1

Breaking Changes (Two Field Renames):

• timestamp → generated: { by, at } — Separates who created from when
• # Citations (body) → sources (frontmatter) — Provenance queryable by agents

New Optional Fields (Additive, Backward-Compatible):

# Provenance tracking  
sources:  
  - resource: policies/revenue-policy.md  
    author: human:jsmith@acme  
    usage_count: 1240  
    usage_window: "2026-01-01 to 2026-06-30"  
  
# Attribution  
generated:  
  by: reference_agent/gemini-2.5-pro  
  at: 2026-06-30T14:00:00Z  
  
# Approval chain  
verified:  
  - { by: human:jsmith@acme, at: 2026-07-01T09:00:00Z }  
  
# Lifecycle management  
status: draft | stable | deprecated  
stale_after: 2026-12-31  
  
# Attested Computation (new concept type)  
runtime: BigQuery | dbt | PostgreSQL | Python | Looker  
parameters: [typed, named bindings]  
computation: sanctioned code path  
executor: run instructions  
attester: deterministic verification (no LLM)  

Trust Signals Framework

Five core questions OKF v0.2 answers:

1. Provenance — What was this created from? (sources)
2. Trust — How much to trust it? (generated, verified)
3. Freshness — Is it still true? (stale_after)
4. Lifecycle — Current version? (status)
5. Attestation — Computed correctly? (Attested Computation)

Trust Tier Derivation (Consumer-Driven):

• Unverified: No generated/verified fields
• Machine-Confirmed: generated.by = agent
• Human-Reviewed: verified[] contains human entries

Compliance Framework

Version Control as Audit Trail:

• Git PRs, diffs, blame enable governance
• Every change is traceable and reversible
• Knowledge curation = software engineering activity

Two-Tier Verification Model:

Level	Field	When	Purpose
Definition	verified[]	Once per change	Confirm definition matches policy
Runtime	Attested Computation receipts	Every execution	Confirm computation ran correctly

Attested Computation for Compliance:

• Agent fills declared parameters only; cannot edit computation
• Executor runs sanctioned SQL/code
• Deterministic attester (no LLM) verifies:
  • Executed code matches sanctioned code
  • Result matches authoritative source
• Failure → agent cannot report value without human review
• Example: Finance defines BigQuery revenue SQL; agent monthly reports; attester confirms exact SQL before display

Provenance Tracking:

• Each source carries: author, usage count, usage window, last modified
• generated.by shows which agent/human created content
• verified[] chain shows approval path with timestamps
• Enables compliance audits without custom runtime systems

Implications for AI Systems

Context Management

Agents gain persistent, curated context instead of static retrieval patterns. Enables:

• Long-term reasoning: Build on shared organizational knowledge
• Memory persistence: Knowledge accumulates across agent interactions
• Relationship reasoning: Navigate concept connections and dependencies

Reduced Technical Debt

Eliminates need for separate infrastructure:

• No embedding pipelines required
• No vector database overhead for structured knowledge
• No retrieval-reranking complexity
• Simpler deployment architecture

Organizational Memory

Knowledge treated like code:

• Version-controlled history of concepts
• Auditable changes and rationale
• Reviewed before acceptance
• Survives personnel transitions

Cross-Agent Collaboration

• Multiple agents share and build on same knowledge base
• Agent A creates knowledge → Agent B reads and reasons → Agent C updates
• Collective intelligence across agent network

Vendor Portability

• Switch LLM providers without knowledge loss
• Migrate between agent frameworks seamlessly
• Export knowledge for external tools
• No platform lock-in

Use Cases

Enterprise Knowledge Management

• Organizational wikis for AI agents
• Curated customer profiles and context
• Product/service documentation
• Business process documentation

AI Agent Orchestration

• Shared context for multi-agent systems
• Long-running agent teams with persistent memory
• Cross-functional knowledge sharing

Research & Development

• Research paper organization with linked concepts
• Literature review structured for agent reasoning
• Hypothesis and experiment tracking

Software Engineering

• Architecture documentation for code agents
• API specifications with examples
• System design documentation

Technical Characteristics

Format Spec

• YAML frontmatter (optional)
• Markdown body (required)
• Standard markdown links for relationships
• No proprietary extensions

Scalability

• Tested with 1000s of documents
• Git-friendly for large repositories
• Efficient agent processing
• No indexing or reranking overhead

Compliance & Trust

• v0.2 onwards: Trust signals framework
• Metadata provenance tracking
• Source attribution
• Lineage tracking for generated knowledge

Alignment with Standards

Holon Community Group

• Exploring alignment with web standards
• Bridging OKF and semantic web
• Expanding use cases beyond AI
• 30+ participants as of June 2026

Relationship to Web Standards

• Complements but doesn’t replace JSON-LD
• Can be converted to/from semantic web formats
• Designed for AI-first use cases
• Simpler alternative for most organizations

Business Use Cases & Real-World Implementations

Deployed Use Cases

BigQuery Dataset Documentation (Google Cloud Reference):

• Enrichment agent crawls BigQuery metadata, generates OKF docs for every table
• Links to schema, join paths, business definitions
• Reference implementations: GA4 e-commerce, Stack Overflow, Bitcoin datasets
• Knowledge Catalog integration serves to agents automatically

Data Team Governance (Common Enterprise Pattern):

• Data teams export BigQuery table/metric definitions as OKF
• Commit alongside SQL code with PR reviews
• Agents query bundle before building queries (semantic understanding)
• Changes reviewable as diffs (schema change → docs must update)

Multi-Agent Reasoning (Strategic Pattern):

• Finance team publishes OKF with revenue definitions and policies
• Sales forecasting agent queries for metric definitions
• Compliance agent queries same bundle to validate agent reports
• One bundle serves multiple agents without duplication

Incident Response Runbooks (Enterprise):

• Ops teams maintain runbooks as OKF
• status: stable | deprecated prevents stale procedures
• verified[] shows which engineers tested it
• Agents filter for human-reviewed runbooks only in critical incidents

WordPress Content Publishing (Community Pattern):

• Plugin generates OKF from WordPress posts
• Serves at /okf/ endpoint, rebuilds on publish
• Makes editorial knowledge machine-consumable

Business Benefits & ROI

Direct Efficiency Gains:

• Reduce knowledge management time 20-40% per team (labor savings)
• Faster agent onboarding (standardized knowledge)
• Single source of truth prevents definition duplicates
• Faster feature delivery (agents deployed with trusted context)

Operational Risk Reduction:

• Prevent analytics errors (agent selects wrong data source)
• Prevent compliance violations (wrong business rules applied)
• Reduce decision error rate (stale_after auto-exclusion)
• Enable compliance sign-off (Attested Computation with deterministic verification)

Strategic Positioning:

• Vendor-neutral → knowledge portable across clouds/models/frameworks
• Early adopters gain governance automation and operational advantage
• Sets industry standard within organization

Enterprise Deployment Patterns

Pattern 1: Producer-Agnostic Knowledge Generation

Data Sources (BigQuery, APIs, Wikis, Code)  
    ↓  
Enrichment Agent (framework-agnostic LLM)  
    ↓  
OKF Bundle (Markdown + YAML frontmatter)  
    ↓  
Version Control (Git with PR workflow)  
    ↓  
Live Documentation + Multi-Agent Context  

How It Works:

1. Reference agent crawls BigQuery metadata, drafts OKF per table
2. LLM enrichment adds citations and join paths
3. Committed to repo with examples (team-forked for internal catalogs)
4. One bundle serves multiple agents without re-creation

Pattern 2: Multi-Tier Approval Workflow

Draft (agent-generated)  
  ↓ (domain owner PR review)  
Stable (main branch, published to agents)  
  ↓ (phase-out scheduled)  
Deprecated (agents warned, status flag)  
  ↓ (archive)  
Deleted (moved to Z_ARCHIVE)  

Governance via Git:

• status: draft = feature branch only
• status: stable = main branch, published
• verified[] chain shows approval path
• Audit trail: full git blame

Pattern 3: Knowledge-as-Code Management (AWS/GCP)

Metadata Extraction (RDS, Redshift, BigQuery, DynamoDB automated)  
    ↓  
OKF File Generation (semi-automated markdown)  
    ↓  
Domain Owner Review (PR gate before agent access)  
    ↓  
Git-Based Version Control (governance + audit)  
    ↓  
Agent Access (continuous feedback loop)  

Why This Matters: Separates reasoning/tools/context into manageable tiers. “Agentic AI remains impressive in demos but fragile in production without governed knowledge layer.”

Pattern 4: Trust-Tier Filtering (Finance/Compliance)

Executive Dashboard (human-reviewed only)  
  └─ Query: verified[].by contains 'human'  
  
Operational Dashboard (machine-confirmed + human-verified)  
  └─ Query: generated.by='agent' AND verified[] not empty  
  
Analytics Sandbox (unverified, for exploration)  
  └─ Query: no filter; labeled by trust tier  

Integration with Enterprise Systems

Google Cloud (Native):

• Knowledge Catalog ingests OKF bundles directly
• Serves to Gemini agents and ADK frameworks
• BigQuery integration: reference agent auto-documents tables

AWS Ecosystem:

• RDS/Aurora/Redshift/DynamoDB metadata → OKF generator → S3
• Agents retrieve bundle from S3 before querying
• SageMaker notebooks embed OKF context in prompts

Generic Systems (No Custom Code):

• Notion, Obsidian: OKF markdown opens directly with YAML intact
• MkDocs: Bundles serve as documentation sites
• Git: Works with GitHub, GitLab, Gitea
• Search: Static visualizers index OKF as HTML
• AI frameworks: LangChain, LlamaIndex, custom agents consume markdown + YAML natively

Compliance Integration:

• Git commit history = audit trail (who, what, when)
• verified[] chain = approval workflow
• generated.by + generated.at = attribution
• Export to compliance tools: query git log, parse frontmatter, generate audit report

When to Use OKF

Use OKF for:

• Persistent organizational knowledge for AI agents
• Curated, high-quality context (vs. raw documents)
• Multi-agent systems needing shared memory
• Governance + audit trails (compliance requirements)
• Portability across LLM providers and frameworks
• Teams that prefer git-based workflows
• Business-critical knowledge (revenue, compliance, policy)
• Knowledge updated frequently by both agents and humans

Consider alternatives if:

• Unstructured document retrieval sufficient (RAG)
• Semantic web interoperability critical (JSON-LD)
• Real-time dynamic data is primary need
• Simple key-value storage suffices
• No governance/audit requirements

See Also

• Retrieval-Augmented Generation
• AI Agentic Systems
• Knowledge Management
• Google Cloud