Knowledge Graph

Open Knowledge Format · v0.2

What is OKF?

OKF is a universal, vendor-neutral way to represent connected knowledge as plain Markdown files with YAML frontmatter. Each file describes a concept using readable content and structured metadata, without requiring a proprietary database or platform.

Markdown links express relationships between concepts, allowing individual files to form portable knowledge bundles. The format keeps knowledge readable by people, parseable by agents, diffable in git, and transferable across tools, organizations, and time.

OKF v0.2 adds optional frontmatter trust signals so agent-maintained corpora stay accountable: provenance (sources), trust (generated, verified), freshness (stale_after), lifecycle (status), and attestation (Attested Computation). Fields remain opt-in; a v0.1 bundle is still valid under v0.2.

This explorer is generated directly from the OKF source files, their links, and structured technology metadata. Graph view turns those relationships into an interactive map with scoped exploration and concept detail panels; Raw Data exposes the exact Markdown and frontmatter behind every concept.

Using the graph

Graph and Raw Data — Use Graph to explore concepts as a connected map with detail panels and scoped navigation. Switch to Raw Data to browse the same bundle as a folder tree of Markdown source files.
Search — Type to filter the current view and surface matching concepts or files in a results list. In Graph mode, search scans titles, types, tags, and descriptions; in Raw Data mode, it matches filenames and file contents.
Show all and Connected — Show all keeps the full visible concept tree on the canvas so you can see the broader bundle structure. Connected narrows the view to the selected concept and its direct links, making nearby relationships easier to inspect.
Expand all and Collapse all — Expand all reveals every child branch in the graph at once for a wider overview of the bundle hierarchy. Collapse all hides those branches again so you can return to a tighter starting layout.
Select a node — Click a node or search result to open the detail panel with frontmatter, rendered Markdown, tags, resource links, and cited-by backlinks. Close the panel to keep more canvas space, then reopen it from the floating action when you want to keep reading.
Double-click a node — Double-click a concept or use its +/− badge to reveal or hide just that node's children. This lets you drill into one branch progressively without changing the broader graph scope.
Fit graph — Use Fit graph to recenter and resize the canvas around the current layout after panning, zooming, or expanding nodes. You can also drag nodes to rearrange them, scroll or pinch to zoom, and use the canvas zoom controls in the corner.
Folders and files — In Raw Data view, expand folders in the left tree and select any .md file to inspect its complete source. The viewer shows the exact frontmatter and body text from the OKF bundle, wrapped for easier reading.
Tags and Categories — Tag and category concepts link outward to the companies they organize, rather than creating dense taxonomy-only connections between labels. This keeps the graph focused on readable relationships between concepts and the entities they reference.

Read the OKF announcement Read about OKF v0.2 trust signals Read the OKF specification Explore OKF documentation

Bottom line

Enterprise AI will not scale because models get larger.
It will scale when context becomes portable, governed, versioned, and supply-chain secure.

The Open Knowledge Format (OKF v0.2) provides a simple, vendor-neutral packaging layer (Markdown + YAML + directories), with optional frontmatter for provenance, trust, freshness, lifecycle, and attestation. What enterprises actually need is an Enterprise OKF Profile and supporting runtime that turn those packages into first-class, auditable, risk-tiered operating artifacts.

This brief outlines that operating model.

Why this matters now

Organizations are moving rapidly from isolated agent pilots to broader production deployments. Context windows remain finite and expensive. Inference cost, tool authorization, and auditability must be declared before execution, not discovered afterward. Maturing protocols (MCP, A2A, agent-generated UI) create clean seams—but only if context itself is portable and contractually governed.

Without a portable layer:

Agents and humans continually reconstruct context
Prompts drift
Retrieval and safety policies diverge
Token spend lacks attribution
Weak provenance makes ungrounded outputs harder to detect

With a portable layer:

One governed bundle
Many consumers
Consistent decision context
Measurable cost and risk control

Three-layer model (dual conformance)

Layer	What it is	Status
1. OKF Core	Markdown concepts + YAML frontmatter + directory conventions, indexes, untyped links, `log.md`, plus optional trust signals (`sources`, `generated`, `verified`, `status`, `stale_after`, Attested Computation)	v0.2 draft specification
2. Enterprise OKF Profile	Declared extension profile that adds ownership, bundle validity, policy declarations, evaluation manifests, harness config, integrity metadata, and typed-link semantics	Enterprise contract (to be defined)
3. Enterprise Runtime	Extraction, registry, validation, identity, authorization, policy enforcement, agent execution, runtime augmentation, observability	Organization-specific

Dual conformance is required for production use:

A bundle must be valid OKF Core (broadly readable without proprietary tooling).
For automated enterprise execution it must also declare and conform to a specific Enterprise OKF Profile version.

Core content is readable without translation. Enterprise extensions require consumers to support the declared profile and its schemas.

OKF core links are untyped by design. Typed semantics (relationship kinds, cardinality, constraints) are supplied only by the enterprise profile when needed.

Concrete example

Context Lake
(CRM · product roadmap · pricing · contracts · battlecards · support · taxonomies · strategy)
          │
          ▼
Extract & Normalize  →  Acme Corp (named account + expansion motion)
          │
          ▼
Enterprise OKF Bundle: acme-expansion-q3-2026/
  • Markdown concept files + YAML frontmatter
  • Untyped core links (enterprise profile may add typed semantics)
  • Bundle manifest (id, version, owner, validity, profile)
  • Detached signature + content-addressed checksums
  • Policy declarations + evaluation manifest
  • Changelog (log.md)
          │
          ▼
Consumers (all working from the same versioned projection)
  Sales expansion agent · Executive copilot · QBR canvas
  Renewal workflow · Compliance review harness

Bundle as governed projection (not absolute truth)

A bundle is a versioned, scoped, time-bound projection of decision context extracted from the authoritative context lake. It is not the system of record. It is the deployable object that humans and agents share at the moment of work.

True portability means the package travels with semantic structure, provenance, policy declarations, evaluation contracts, lifecycle metadata, and integrity controls. A consumer that understands the declared enterprise profile can inspect, version, audit, evaluate, and safely execute against it.

Dynamic context remains essential. The bundle is the stable baseline; runtimes routinely augment it with real-time signals (CRM updates, incidents, telemetry) and session state.

Bundle lifecycle & risk-tiered controls

Create → Validate → Evaluate → Approve → Publish → Deploy → Observe → Revise → Retire

Evaluation and integrity are risk-tiered:

Risk Tier	Evaluation	Integrity Controls
Low (internal research, non-customer)	Lightweight checks, self-evaluation allowed	Basic checksums + publisher identity
Medium (customer-facing, revenue)	Independent evaluation suite, holdout datasets	Signed manifest + content-addressed storage
High (regulated, financial, safety-critical)	Separate organizational evaluators, protected datasets, dual approval	Detached cryptographic signature, revocation support, secret scanning, admission policy at registry and runtime

Evaluation assets should be independently governed from the content they test. High-risk bundles require different roles for content ownership and evaluation approval.

Governance: declarations vs enforcement

Governance declarations travel with the bundle.
Enforcement remains the responsibility of the consuming runtime + identity + authorization systems.

Under an Enterprise OKF Profile the bundle can declare:

Permitted model tiers, tools, retrieval indexes, token budgets
Explicitly forbidden actions (internet, email send, payments, code execution, unscoped writes)

The bundle is a vehicle for policy declaration.
The runtime is the policy decision and enforcement point.
Identity systems verify subjects. Audit systems record evidence.

Integrity & supply-chain security

Because bundles are deployable infrastructure they require software-supply-chain controls:

Bundle manifest (id, version, owner, profile, validity, references)
Detached cryptographic signatures by trusted publishers
Content-addressed checksums / manifests
Publisher identity and provenance lineage
Classification labels, secret scanning, external-link controls
Revocation lists and tamper detection
Admission policies at registry and runtime

An attacker or compromised producer could otherwise alter instructions, policy declarations, citations, relationships, evaluation answers, or tool scopes.

Interoperability architecture

Work surfaces and interaction protocols are distinct. Observability is cross-cutting.

┌────────────────────────────────────────────────────────────┐
│  Work Surfaces                                             │
│  Collaborative Canvas · Copilot UI · Workflow UI · Human   │
└───────────────────────────┬────────────────────────────────┘
                            │ uses
┌───────────────────────────▼────────────────────────────────┐
│  Interaction Protocols                                     │
│  AG-UI / A2UI (agent-generated UI)                         │
└───────────────────────────┬────────────────────────────────┘
                            │
┌───────────────────────────▼────────────────────────────────┐
│  Agent & Workflow Runtimes                                 │
│  Single-agent · Multi-agent · A2A collaboration            │
└───────────────────────────┬────────────────────────────────┘
                            │ loads via
┌───────────────────────────▼────────────────────────────────┐
│  Context Consumption Layer                                 │
│  OKF loader · search · graph traversal · runtime augment.  │
└───────────────────────────┬────────────────────────────────┘
                            │
┌───────────────────────────▼────────────────────────────────┐
│  Enterprise OKF Bundles                                    │
│  Core OKF + declared Enterprise Profile + Manifest + Sig.  │
└───────────────────────────┬────────────────────────────────┘
                            │ distributed via
┌───────────────────────────▼────────────────────────────────┐
│  Distribution & Access                                     │
│  Git · Object storage · Registry · MCP resources · APIs    │
└───────────────────────────┬────────────────────────────────┘
                            │ sourced from
┌───────────────────────────▼────────────────────────────────┐
│  Source Systems                                            │
│  CRM · CMS · Support · Data Lake · Knowledge Graph · etc.  │
└────────────────────────────────────────────────────────────┘

Observability is cross-cutting across every layer:
bundle version · files referenced · tools called · token cost ·
evaluation score · drift · full audit trail

MCP exposes tools/resources. A2A enables agent-to-agent collaboration. They solve different problems and are not collapsed into one box. An OKF bundle may be exposed as an MCP resource, loaded from Git/object storage, transferred as an A2A artifact, or mounted locally.

Composable harnesses

Instead of only tagging an agent into a channel or workspace, organizations can tag an agent with a specific OKF bundle. That tag becomes a composable harness declaring:

which subgraph to load
which tools and retrieval indexes are in scope
which model tiers and token budgets are authorized
which evaluation checks and safety policies apply
which human review paths must be attached

The same base runtime is specialized into a sales expansion agent, regulated support agent, product launch agent, or executive briefing agent simply by changing the bundle and its harness definition.

Complementary positioning

OKF is complementary, not a replacement:

RAG → retrieval. An enterprise OKF bundle packages a selected, governed, versioned projection.
Knowledge graphs / Neo4j / GraphQL → storage & query. OKF is the shippable artifact extracted from them.
MCP resources → tools & data exposure. An OKF bundle can be the payload or the scoping configuration.
SharePoint / Notion / Confluence → collaboration surfaces that can produce OKF bundles.

Expected outcomes (to validate in pilots)

When organizations treat bundles as first-class artifacts under an Enterprise OKF Profile:

Reduced prompt-engineering and context-assembly effort per new agent
Lower token consumption through precise scoping and validity windows
Higher evaluation pass rates and lower rates of ungrounded responses
Faster agent onboarding
Lower approval latency
Higher context reuse and lower rebuild tax
Full auditability (every decision traced to a specific bundle version)
Attributable inference cost by workflow, account, or business unit

These are realistic targets for controlled pilots, not guaranteed results.

Closing thesis

Enterprise AI will not scale because models become larger.
It will scale because context becomes portable, governed, reusable, and versioned.

Organizations that apply the same engineering discipline already used for source code, APIs, containers, and software artifacts—including dual conformance (OKF Core + Enterprise Profile), risk-tiered evaluation, and supply-chain security—will pull ahead.

In the next generation of enterprise systems, context itself becomes deployable infrastructure.

OKF is an open draft specification (v0.2). Core now includes optional trust signals for provenance, verification, freshness, lifecycle, and attestation. Evaluation contracts, policy declarations, integrity controls, composable harnesses, observability, and the context supply chain remain enterprise practices enabled by an Enterprise OKF Profile and supporting runtime—not redefinitions of the core specification.

A Connected View of Work and Knowledge

A living knowledge map generated from portable Markdown concepts, structured metadata, and the relationships between them.