Open Knowledge Format as RDF Documents

Overview

The source article introduces OKF as Markdown plus YAML frontmatter for portable agent context. This collection shows the same idea as an RDF document bundle: Turtle files are the documents, ontology terms define the contract, and instance data carries the actual business context.

Relevant context limits agentic systems

Foundation models can write code, summarize documents, and analyze data, but accurate action still depends on context.

OKF formalizes the LLM-wiki pattern

OKF v0.1 turns a directory of Markdown files with YAML frontmatter into a portable, vendor-neutral knowledge format.

Enterprise context is fragmented

Schemas, metrics, runbooks, APIs, joins, code comments, documents, and expert memory live across incompatible surfaces.

The problem needs a format, not another service

OKF emphasizes producer and consumer independence over a new runtime, SDK, or proprietary platform.

OKF uses file paths as concept identity

In the v0.1 design, each Markdown file represents a concept and the file path is the concept identity.

Markdown links make a graph

Concept documents link to each other with Markdown links, creating richer relationships than the directory tree alone.

OKF is a starting point

The specification is intentionally versioned, open, and expected to evolve as producers and consumers appear.

Compare And Contrast

OKF’s Markdown design optimizes for immediate adoption. RDF-Turtle adds formal semantics, queryability, and Web-scale identity while preserving text-file portability.

OKF Markdown document pattern

Directory of Markdown files. YAML frontmatter stores type, title, description, resource, tags, and timestamp. File paths identify concepts. Markdown links create a navigable graph for agents and people.

RDF-Turtle document pattern

Directory of Turtle files. HTTP IRIs identify concepts. RDF predicates type relationships. Ontology classes and properties travel with the bundle. SPARQL queries cross documents without custom parsing.

Identity

OKF Markdown: file path is identity. RDF-Turtle: HTTP IRIs identify entities independent of local storage paths.

Relationship semantics

OKF Markdown: links are readable but mostly untyped. RDF-Turtle: predicates make relationships explicit and machine-actionable.

Query model

OKF Markdown: search tools and conventions. RDF-Turtle: SPARQL over typed triples, named graphs, provenance, and ontology terms.

Portability

OKF Markdown: portable files and Git repositories. RDF-Turtle: portable files plus Web-scale entity references and graph federation.

Validation

OKF Markdown: frontmatter fields and repository rules. RDF-Turtle: parser validation plus optional SHACL and ontology constraints.

Schema evolution

OKF Markdown: conventions evolve through spec versions. RDF-Turtle: ontologies publish classes and properties that can be extended incrementally.

Human authoring

OKF Markdown: familiar writing workflow. RDF-Turtle: more structured, but still text-based and readable when authored carefully.

Agent consumption

OKF Markdown: agents parse directories and frontmatter. RDF-Turtle: agents traverse typed graphs and execute SPARQL queries.

Ontology Layer

The Turtle file declares a lightweight ontology for RDF-first OKF bundles. Each class and property axiom is linked to a concrete example resource in the RDF source.

RDF Knowledge Bundle

A deployable collection of RDF documents, ontologies, instance data, and query recipes that can be consumed by humans, agents, and SPARQL engines.

Semantic Document

A document whose identity, type, metadata, body sections, and relationships are represented as RDF triples.

Context Atom

A reusable unit of agent context such as a table, metric, runbook, API, dataset, join path, or concept.

Comparison Dimension

A criterion used to compare OKF Markdown documents with RDF-Turtle documents.

SPARQL Recipe

A saved query over the RDF document collection.

Linked Data Principle

A principle for naming, dereferencing, and interlinking entities on the Web.

denotes resource

Connects a semantic document or context atom to the entity it identifies.

has context atom

Connects a bundle or document to a reusable unit of context.

queryable by

Connects a bundle or entity group to a SPARQL recipe.

contrasts with

Connects one representation strategy to another in a comparison.

implements principle

Connects an RDF document pattern to a Linked Data principle.

Axiom Examples

These examples show valid ABox usage for the custom classes and properties, including domain/range intent for each predicate.

Example: RDF Knowledge Bundle class axiom

Shows a valid bundle instance with semantic documents, context atoms, and SPARQL recipes.

Example of: RdfKnowledgeBundle

:rdfBundle a :RdfKnowledgeBundle ;
  schema:hasPart :doc-sales-index ;
  :hasContextAtom :atom-bigquery-table ;
  :queryableBy :query-context-atoms .

Example: Semantic Document class axiom

Shows a semantic document instance denoting a reusable context resource.

Example of: SemanticDocument

:doc-orders-table a :SemanticDocument ;
  schema:name "sales/tables/orders.ttl"@en ;
  :denotesResource :resource-orders-table .

Example: Context Atom class axiom

Shows a context atom as a reusable unit of agent context inside the RDF bundle.

Example of: ContextAtom

:atom-metric a :ContextAtom ;
  schema:name "Metric"@en ;
  schema:isPartOf :rdfBundle .

Example: Comparison Dimension class axiom

Shows a comparison dimension contrasting the Markdown and RDF-Turtle representation patterns.

Example of: ComparisonDimension

:dim-query a :ComparisonDimension ;
  schema:name "Query model"@en ;
  :contrastsWith :okfMarkdownPattern, :rdfTurtlePattern .

Example: SPARQL Recipe class axiom

Shows a query recipe typed as both the local class and schema.org source code.

Example of: SparqlRecipe

:query-context-atoms a :SparqlRecipe, schema:SoftwareSourceCode ;
  schema:programmingLanguage "SPARQL"@en ;
  schema:target <https://linkeddata.uriburner.com/sparql> .

Example: Linked Data Principle class axiom

Shows a Linked Data principle represented as a reusable defined term in the collection.

Example of: LinkedDataPrinciple

:principle-http-iris a :LinkedDataPrinciple ;
  schema:name "Use HTTP IRIs as names"@en ;
  schema:isPartOf :linkedDataPrinciples .

Example: denotes resource property axiom

Shows the domain/range intent: a semantic document denotes a context atom.

Example of: denotesResource

:doc-orders-table :denotesResource :resource-orders-table .

Example: has context atom property axiom

Shows the domain/range intent: a bundle contains a reusable context atom.

Example of: hasContextAtom

:rdfBundle :hasContextAtom :atom-bigquery-table .

Example: queryable by property axiom

Shows the domain/range intent: a bundle is queryable by a SPARQL recipe.

Example of: queryableBy

:rdfBundle :queryableBy :query-context-atoms .

Example: contrasts with property axiom

Shows the comparison relationship between a dimension and the two representation patterns.

Example of: contrastsWith

:dim-query :contrastsWith :okfMarkdownPattern, :rdfTurtlePattern .

Example: implements principle property axiom

Shows an RDF document pattern implementing Linked Data principles.

Example of: implementsPrinciple

:rdfTurtlePattern :implementsPrinciple :principle-http-iris .

Instance Data

These are sample semantic documents and context atoms for a sales-oriented OKF-style bundle.

sales/index.ttl

Collection index for the sales context bundle.

sales/datasets/orders_db.ttl

Dataset profile for the sales orders database.

sales/tables/orders.ttl

Table profile for completed customer orders.

sales/tables/customers.ttl

Table profile for customer records.

sales/metrics/weekly_active_users.ttl

Metric definition and lineage for weekly active users.

ops/runbooks/incident_response.ttl

Runbook context for agent-assisted incident response.

BigQuery table

A data warehouse table represented as a typed entity with schema, resource URL, owners, and relationships.

Dataset

A collection of tables, views, or data products with ownership and usage metadata.

Metric

A reusable business measure with a formula, provenance, grain, source tables, and governance notes.

Join path

A relationship showing how two data entities are connected by keys or graph predicates.

Runbook

Operational instructions that agents can retrieve, traverse, and update.

API

A service interface represented as a discoverable entity with operations and examples.

Provenance record

A trace of source, author, timestamp, and derivation for a context atom.

Benefits Of RDF, Linked Data, And SPARQL

The payoff is not aesthetic. It is operational: context becomes identifiable, mergeable, queryable, and reusable across tools.

Global joinability

A table, metric, runbook, and API can be related through IRIs rather than trapped in one repository tree.

Precise relationship meaning

Predicates distinguish schema:about, schema:isPartOf, prov:wasDerivedFrom, okfx:denotesResource, and business-specific links.

Cross-document questions

SPARQL can ask which metrics depend on a deprecated table or which runbooks mention a failing API.

Provenance as data

Authors, publication dates, derivations, source URLs, and generation steps can be queried rather than hidden in prose.

Agent planning substrate

Agents can traverse known relationships, inspect ontology terms, and choose next actions from graph shape.

No required SDK

Like OKF, Turtle files can live in Git, tarballs, object stores, or WebDAV, while remaining more formally queryable.

Linked Data Principles

Use HTTP IRIs as names

Things should be named with HTTP IRIs so people and agents can refer to the same entity across documents and systems.

Dereference names into descriptions

Looking up an IRI should lead to useful information about the named entity.

Describe things with RDF

Descriptions should use RDF statements so data from many sources can merge into one graph.

Include links to other things

RDF should connect entities to other IRIs so graph discovery and reuse improve over time.

Explore Knowledge Graph

SELECT queries use text/x-html+tr. DESCRIBE and CONSTRUCT use text/x-html-nice-turtle.

Graph IRIRecipeQueryResult format

SPARQL recipes

The recipes are represented as schema:SoftwareSourceCode entities in the Turtle graph and can be run after loading the graph into https://linkeddata.uriburner.com/sparql.

FAQ

What did Google Cloud introduce?

Google Cloud introduced Open Knowledge Format v0.1, an open specification for representing agent and human knowledge as Markdown documents with YAML frontmatter.

What problem does OKF address?

OKF addresses fragmented enterprise context: schemas, metrics, runbooks, APIs, joins, documents, and expert knowledge split across incompatible systems.

Why does this collection use RDF-Turtle instead of Markdown?

It demonstrates how the same document-collection idea can be represented as linked, typed RDF documents with ontology and instance data.

What is the main benefit of RDF over Markdown links?

RDF links are typed predicates between identified things, so an agent can know whether a link means about, depends on, joins to, derives from, or implements.

Does RDF replace OKF?

Not necessarily. RDF can be an alternate OKF serialization, an enrichment layer, or the source-of-truth format for teams that need graph queries and Linked Data interoperability.

Why are Linked Data principles important here?

Linked Data makes context atoms portable beyond a local folder by using dereferenceable IRIs and RDF descriptions that can join other graphs.

How does SPARQL improve agent consumption?

SPARQL gives agents a standard way to ask graph-shaped questions across documents, types, relationships, provenance, and examples.

What tradeoff does RDF introduce?

RDF-Turtle is more explicit and structured than Markdown, which improves machine actionability but requires more care in authoring and validation.

How can humans still read RDF docs?

Turtle is a text format with prefixes, compact triples, labels, comments, and descriptions; a companion HTML view can provide the friendly reading surface.

What should a practical RDF OKF bundle contain?

It should contain ontology terms, typed instance documents, provenance, cross-links, glossary terms, query recipes, and a small set of conformance rules.