OKF vs llms.txt vs MCP:
What's the Difference?

Quick Overview

If you're building for the AI agent ecosystem, you've probably encountered three standards: OKF (Open Knowledge Format), llms.txt, and MCP (Model Context Protocol). Each solves a different problem, but they're often confused.

Below, we break down each standard and show you how to use them together for maximum agent discoverability.

What Is llms.txt?

llms.txt is a single markdown file (placed at the root of a website) that tells LLMs what pages exist and what they contain. It's defined by the llmstxt.org standard.

How It Works

# Site Name — Description
> One-line summary

## Core pages

- [Documentation](https://example.com/docs): Setup and usage guides
- [API Reference](https://example.com/api): Complete API documentation
- [FAQ](https://example.com/faq): Answers to common questions

## Additional resources

- [Blog](https://example.com/blog): Latest updates and tutorials
- [GitHub](https://example.com/github): Source code and issues

Key Characteristics

• Single file — one markdown file for the entire site
• Link-based — it's a manifest of URLs, not content itself
• No metadata — basic descriptions, no structured frontmatter
• Browser-based consumption — the LLM must fetch each linked page
• Simple setup — just create a text file and deploy it

llms.txt is excellent for discovery. When an agent lands on your site, it checks /llms.txt and immediately knows what pages exist. But it doesn't give the agent the actual knowledge — it just points to where the knowledge lives.

What Is OKF?

OKF (Open Knowledge Format) is a directory-based standard for packaging knowledge as structured markdown files. Launched by Google Cloud Platform in mid-2026, it's designed for agents to consume directly without needing to browse or fetch additional pages.

How It Works

my-knowledge-bundle/
├── index.md         # Bundle manifest with YAML frontmatter
├── log.md           # Changelog
├── concepts/
│   ├── setup.md     # Concept document with metadata
│   └── architecture.md
└── guides/
    ├── getting-started.md
    └── configuration.md

Key Characteristics

• Directory structure — knowledge is organized in a hierarchy of markdown files
• YAML frontmatter — every file has structured metadata (title, description, tags, version)
• Self-contained — the agent gets all the knowledge it needs without fetching additional URLs
• Cross-linked — concepts link to each other, forming a knowledge graph
• Version-controlled — bundles live in git, with full history and collaboration via PRs

OKF is the format used by BundleDex, the definitive directory of OKF bundles. It's ideal for deep, structured knowledge that an agent needs to understand a domain before working with it.

What Is MCP (Model Context Protocol)?

MCP is a protocol for AI agents to interact with live tools and services in real-time. Developed by Anthropic, it defines how agents can discover and call server-provided tools during a session.

How It Works

// MCP follows a client-server model:
//
// 1. Agent (client) connects to MCP server via stdio or SSE
// 2. Handshake: server advertises available tools/schemas
// 3. Agent calls tools as needed during the session
// 4. Server returns results in real-time

// Example: MCP tool definition
{
  "name": "search_docs",
  "description": "Search documentation for a query",
  "inputSchema": {
    "type": "object",
    "properties": {
      "query": { "type": "string" }
    }
  }
}

Key Characteristics

• Real-time protocol — live interactions with tools and data
• Client-server architecture — requires a running server
• Dynamic interaction — tools respond to queries with live data
• Ephemeral connections — no built-in persistence
• Server infrastructure needed — someone must run and maintain the MCP server

MCP is ideal for live operations — querying a database, searching documentation, calling APIs, or interacting with current system state. It's not for static knowledge (that's what OKF is for).

Side-by-Side Comparison

When to Use Each Standard

Use llms.txt When...

• You have a website with multiple pages an agent should know about
• You want to provide a simple, scannable manifest of your site's content
• You need a quick, low-effort way to make your site agent-discoverable
• Your content is already written and accessible via URLs

Use OKF When...

• You have domain knowledge that an agent needs to understand deeply
• You want to package knowledge that's portable across agent platforms
• Your knowledge changes over time and needs version control
• You want your knowledge discoverable on BundleDex (the OKF directory)
• You're building tools, SDKs, or libraries that agents need to use

Use MCP When...

• You have live data or services that agents should query in real-time
• You're building database-backed tools, search APIs, or system monitors
• Your data changes frequently and can't be pre-packaged as static files
• You need agents to perform actions (write, update, delete) through your system

Using Them Together: The Three-Layer Approach

The most effective AI agent setups use all three standards together in a layered architecture:

Layer 1: llms.txt (Discovery)
├── Points agents to your site's key pages
└── Includes links to your OKF bundle locations

Layer 2: OKF Bundles (Knowledge)
├── Provides deep, structured domain knowledge
├── Agent loads into context before starting work
└── Discoverable via BundleDex API

Layer 3: MCP Servers (Live Access)
├── Gives agents real-time tool access
├── Queries databases, search, and live APIs
└── Complements static OKF knowledge

Example: The Complete Setup

Here's how a well-configured site uses all three:

example.com/
├── /llms.txt                    # Agent discovery: "Here are my pages"
├── /okf/                        # OKF bundle directory
│   ├── index.md                 # "Here's my domain knowledge"
│   ├── concepts/
│   └── guides/
├── /mcp                         # MCP endpoint
│   └── (Server via bundledex.net/mcp)
└── /api/bundles.json            # BundleDex API for programmatic access

In practice, this means:

1. An agent visits your site and reads /llms.txt to discover your OKF bundle
2. The agent loads your OKF bundle to understand your domain deeply
3. During work, the agent calls your MCP server for live data
4. Everything is discoverable via BundleDex, the OKF directory

FAQ