BundleDex / Guides / Validate OKF Bundles

How to Validate an OKF Bundle

A complete, step-by-step guide to understanding and verifying OKF bundle conformance — with real examples from the BundleDex index of 821 bundles.

Updated July 15, 2026 ~10 min read

What Is OKF Conformance?

OKF conformance means a bundle follows the formal OKF specification — a structured set of rules covering directory layout, file naming, YAML frontmatter schema, cross-linking conventions, and version compatibility. A conformant bundle is guaranteed to work with any OKF-compatible tool.

Current Status: Of the 821 bundles on BundleDex, 311 (38%) are OKF-conformant. The other 510 bundles use markdown-based knowledge structures but haven't been validated against the spec yet.

What Conformance Checks

  • Directory structure: Must have index.md, SPEC.md, and a concepts/ directory
  • Frontmatter schema: index.md must include name, description, okf_version
  • Cross-links: Concept files must link to each other using OKF-style references
  • Version compatibility: Bundle's okf_version must match a supported spec version
  • No orphaned files: All markdown files should be referenced from the bundle index

Step 1: Check Conformance on BundleDex

The quickest way to check a bundle's conformance status is on BundleDex. Every bundle page shows a conformance badge:

1

Navigate to any bundle page

Go to bundledex.net/bundles/<slug>/ for any bundle in our index.

2

Look for the conformance badge

If the bundle is conformant, you'll see a green OKF Conformant badge. Non-conformant bundles show a Not Checked badge.

3

Check via API

BundleDex's JSON API includes a okf_conformant boolean field for every bundle. You can query it programmatically:

curl https://bundledex.net/api/bundles.json | \
  jq '.bundles[] | select(.okf_conformant == true) | .name'

Step 2: Use the OKF Conformance Tool

For thorough validation, use the OKF Conformance tool — the official validator for OKF bundles. It runs a comprehensive test suite against any bundle directory.

Installation

# Clone the conformance tool
git clone https://github.com/YOUR_ORG/okf-conformance
cd okf-conformance

# Run against a bundle
python validate.py /path/to/your-bundle/

What It Validates

  • Structural checks: Required files exist, no unknown top-level files
  • Frontmatter validation: All required YAML fields present and correctly typed
  • Cross-link integrity: Every concept link points to an existing file
  • OKF version check: Bundle declares a valid okf_version
  • Content quality: Descriptions are non-empty, titles are meaningful

Other validation tools include okf-lint for frontmatter linting, OKF Go Parser for programmatic Go-based validation, and okf-schema for Python/JSON Schema validation.

Step 3: Manual Validation Checklist

If you prefer to check manually, here's a quick checklist:

index.md exists at bundle root
index.md has YAML frontmatter with name, description, okf_version
SPEC.md exists and describes bundle structure
concepts/ directory contains concept markdown files
Each concept file has frontmatter with title, type
Cross-links use OKF format: [text](concept-slug)
No markdown files outside concepts/ (except index.md and SPEC.md)
Repository has okf topic tag on GitHub
Pro Tip: Even if your bundle isn't fully conformant, it can still be useful. Many agents can load non-conformant bundles. Conformance is a quality signal — it tells users your bundle will work reliably with any OKF tool.

Step 4: Automate Validation in CI

The best practice is to validate your OKF bundle on every commit. Here's a GitHub Actions workflow:

# .github/workflows/okf-validate.yml
name: Validate OKF Bundle
on: [push, pull_request]
jobs:
  validate:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Check directory structure
        run: |
          test -f index.md || (echo "Missing index.md" && exit 1)
          test -f SPEC.md || (echo "Missing SPEC.md" && exit 1)
          test -d concepts || (echo "Missing concepts/" && exit 1)
      - name: Validate frontmatter
        uses: okf-lint/action@v1
        with:
          path: .

You can also use Surface for documentation quality checks in CI, which catches issues like documentation drift and missing cross-references.

Real Examples from the Index

Here are examples of conformant and non-conformant bundles from the BundleDex index:

✅ Conformant Bundles

#1
iwe by iwe-org OKF Conformant

Markdown memory system for you and your AI agent

#2
okf-agent-memory by okf-memory OKF Conformant

Git-native persistent memory for AI coding agents. Implements Google OKF v0.2 with sub-300µs in-memory BM25 search, embedded MCP server, and progressive disclosure. Slashes token bloat by 80% with zero external databases or dependencies. Built in pure Go.

#3
lineage-skill by JuneYaooo OKF Conformant

Distill videos, PDFs, transcripts, and notes into source-backed teacher Agent Skills.

These bundles pass all conformance checks. Their structure is verified to match the OKF specification, and they're guaranteed to work with any OKF-compatible agent or tool.

⚠️ Non-Conformant Bundles (for comparison)

#1
cole-medin-knowledge-base by coleam00 Not Checked

An OKF (Open Knowledge Format) knowledge base + Karpathy-style LLM wiki synthesized from Cole Medin's entire long-form YouTube catalog. Drop it next to any project for agent-ready, cited reference. No database, no embeddings. — This bundle uses markdown-based knowledge but hasn't been formally validated against the OKF spec.

#2
okf-rs by jyjeanne Not Checked

A fast, open-source Rust toolkit for generating, validating and serving Open Knowledge Format (OKF) knowledge bases from source code. — This bundle uses markdown-based knowledge but hasn't been formally validated against the OKF spec.

#3
wiki-as-an-mcp by taikunudel Not Checked

First general Wiki MCP following google's Open Knowledge Format. Let your agent to use, manage, maintain, and health check the wiki (knowledge base) for you. The wiki is general purpose. — This bundle uses markdown-based knowledge but hasn't been formally validated against the OKF spec.

Non-conformant status doesn't mean a bundle is bad — many excellent OKF bundles are in this category. It simply means they haven't been validated. As the ecosystem matures, we expect more bundles to achieve conformance.

Frequently Asked Questions

Does my bundle need to be conformant to be listed on BundleDex?

No. BundleDex indexes all public OKF bundles regardless of conformance status. Conformance is displayed as a badge to help users evaluate quality.

How do I get my bundle officially validated?

Run the OKF Conformance tool against your bundle directory. If all checks pass, your bundle can be submitted for official conformance verification through the OKF specification repository.

What happens if my bundle doesn't pass validation?

The validator will report specific failures. Common issues include missing index.md, incorrect frontmatter fields, or orphaned concept files. Fix the reported issues and re-run validation.

Do AI agents prefer conformant bundles?

Yes. Agents like Claude Code and Cursor can parse conformant bundles more reliably because they know the structure is consistent. Non-conformant bundles may still work, but with less predictability.

Are there different levels of conformance?

The current OKF spec defines binary conformance (conformant or not). Future versions may introduce graduated conformance levels for different use cases.

Get Your Bundle Validated

Check any bundle's conformance status on BundleDex, or submit your own for indexing.

Browse Bundles → Submit a Bundle →