Google’s Open Knowledge Format (OKF) gave agents a portable way to document knowledge. Connected to the OriginTrail Decentralized Knowledge Graph (DKG), that knowledge becomes something an agent can prove, own, and build on: a shared memory, not a model’s best guess.
Everything humans have built, we built on knowledge we inherited. We don’t rediscover fire every morning. We stand on what others worked out before us, and we trust it because we can trace it: a source, a citation, a name behind the claim. AI agents have none of that inheritance. Each one wakes up empty, re-derives the world from scratch, and when it tells you something, neither it nor you can say where that knowledge came from, or whether to believe it. That gap, knowledge with no memory and no provenance, is the real reason we still hesitate to hand AI the decisions that matter.
This integration begins to close that gap. We’ve connected Google’s Open Knowledge Format (OKF) (an open, vendor-neutral standard for recording knowledge as portable Markdown that any system can read — V1 introduced in June 2026) to the OriginTrail Decentralized Knowledge Graph (DKG), the layer that gives that knowledge an origin, an owner, and a proof. OKF is portable by design but deliberately carries no trust layer: Google itself lists trust tiers among the open questions in v0.1. The DKG is exactly that missing layer.
On its own, OKF is portable text; the DKG is what makes that text trustworthy. Together, they turn a static bundle into a living memory that any permitted agent can subscribe to, query, and, above all, trust.
Open Knowledge Format (OKF): Write knowledge once, read it anywhere
Take OKF on its own first. Machine-readable knowledge is scattered today (across catalogs, wikis, code comments, and private stores), so every agent rebuilds its context from scratch. OKF replaces that with a single portable artifact: a bundle of plain-Markdown concept files, each with light YAML frontmatter and links to related concepts, where the format itself is the only contract.
Any tool can write a bundle and any tool can read it (no SDK, no runtime, no translation, no platform to adopt), so knowledge is written once and stays readable by anything, anywhere.
OKF to Decentralized Knowledge Graph (DKG): Context imported, not invented
One command does the whole thing — transforming the OKF into verifiable knowledge on the DKG:
dkg okf import <bundle> — context-graph-id <cg> — create-context-graph — share
But the command isn’t the point; what it refuses to do is. There is no LLM anywhere in the import path. The mapping from an OKF bundle to the graph is pure and deterministic: the same bundle produces byte-identical triples, every time, on any machine. This can read like a technical footnote, but it is, in fact, the foundation the rest stands on.
A signed, owned, “verifiable” fact is only as trustworthy as the step that produced it, and if that step is a language model’s best guess, you haven’t built verifiable memory, you’ve built a verifiably signed hallucination.
Deterministic import is what lets the DKG’s provenance mean something: it proves not just who asserted a fact, but that the fact faithfully reflects its source, and anyone can re-run the import and get exactly the same graph. It also keeps faith with OKF itself: cross-links become untyped directed edges, exactly as the spec defines them, with no invented relationship types. Nothing is embellished, nothing is guessed; what was written is what gets remembered.
Demo: Microstrategy’s Bitcoin treasury, traced to two sources
Take a real provenance problem. Strategy Inc (Nasdaq: MSTR, formerly MicroStrategy) holds the world’s largest corporate Bitcoin treasury, disclosed purchase-by-purchase in SEC Form 8-K filings and re-published by community dashboards. We collated it into an OKF bundle from two sources of differing authority: SEC EDGAR (the filings themselves) and SaylorTracker, a derived dashboard used only as a cross-check.
Before DKG: The bundle is a folder of plain Markdown concepts, one per SEC Form 8-K filing, plus a concept for each source. Every transaction records its numbers and cites both sources: SEC EDGAR as the authoritative record, SaylorTracker as the cross-check. But that provenance is only prose and links. A person can read which filing a number came from; nothing can query which transactions are EDGAR-verified, reconcile the two sources, or prove the chain from a holdings figure back to the 8-K that established it.
The concept the figure highlights, transactions/2026–04–19.md, as it sits in the bundle. Its numbers are YAML frontmatter; its two sources are ordinary Markdown links, nothing the bundle itself can act on.
— —
type: Bitcoin Treasury Transaction
title: Strategy BTC acquisition, 2026–04–13 to 2026–04–19
btc_delta: 34164
avg_price: 74395
cumulative_btc: 815061
tags: [mstr, bitcoin, treasury, acquisition, edgar-verified]
# usd_amount, period dates, accession_no, … the rest of the disclosure fields
— —
# Provenance
Primary source: [SEC EDGAR](../sources/sec-edgar.md), Form 8-K announced 2026–04–20.
Reconciliation: [SaylorTracker](../sources/saylortracker.md), the derived dashboard.
# Citations
[1] [SEC Form 8-K, Strategy Inc (CIK 0001050446), 2026–04–20](https://www.sec.gov/cgi-bin/browse-edgar?action=getcompany&CIK=0001050446&type=8-K), authoritative.
[2] [SaylorTracker](https://saylortracker.com/), cross-check.
After DKG: Imported into the Decentralized Knowledge Graph, every citation becomes a first-class edge, and each source becomes a node that its transactions point to.
The two-source provenance turns into a queryable structure, checked with SPARQL (which filing backs a metric, which purchases are EDGAR-verified), and the bundle becomes owned, verifiable Knowledge Assets carrying cryptographic provenance (a Merkle root plus an EIP-712 attestation).
An agent no longer just reads that EDGAR is authoritative; it can verify the chain from a number to the filing.
The provenance that existed only as prose citations is now edges in a graph database that any permitted system can traverse, query, and verify. A treasury record collated from public filings became knowledge that an agent can prove, own, and build on.
Why OKF needs the DKG
A portable file is only as trustworthy as the hands it has passed through. That is the catch with any knowledge format on its own: OKF can carry knowledge anywhere, but take away who wrote it and whether it has been altered, and you are left with text that looks authoritative and proves nothing, which is the exact failure mode that makes today’s AI knowledge so hard to rely on.
The DKG is the half that changes that. It turns each piece of knowledge into something an agent can stand behind:
- Cryptographically authored, so you know who asserted it;
- Owned, so it has an accountable origin instead of drifting unattributed;
- Verifiable, so a machine can check it rather than take it on faith;
- Shared, so many agents build on one memory instead of each guessing alone.
This makes the difference between an agent saying “I think I read somewhere…” and “here is the fact, here is who stands behind it, and here is the proof.”
What verifiable context running on OKF + DKG unlocks
The DKG already runs in settings where provenance is non-negotiable, and knowledge has to cross organizational lines: international supply chains and trade, pharmaceutical and healthcare distribution, manufacturing, and scientific research, where the hard part has never been storing data but trusting data coming from someone else.
Verified factory audits shared between competing retailers, medicines traced to the patients they were meant for, customs risk assessed from authenticated shipment records: in each case, the value comes from knowledge that can be proven, not merely presented. OKF widens the on-ramp to all of it. Any team that can write Markdown can now turn what it knows into verifiable, ownable assets on the same infrastructure.
The wider opportunity is the web itself. As AI agents become the main readers of online content, site owners face a defensive choice: block the bots, or watch them take value for free. Robots.txt bans, crawler walls, and paywalls are all the same instinct, and together they are producing a web that quietly closes itself to machines. Verifiable context offers the other road.
Because knowledge published through the DKG is owned, provenanced, and permissioned, a site can expose a discoverable, machine-readable signal of what it knows, keep the substance gated, and sell an agent access instead of refusing it. The properties that make the knowledge trustworthy are the same ones that make it sellable: the agent can confirm that it is paying for genuine, attributable knowledge, and the owner can prove exactly what was sold.
Letting agents pay their way in
Payment is the last piece, and it is coming into view. One emerging option is the x402 protocol, which revives HTTP’s long-dormant “402 Payment Required” response. It enables any agent to pay for a resource in stablecoins and TRAC tokens at the moment they request it. Paired with owned, permissioned knowledge, it suggests a natural upgrade path: an agent discovers a dataset, the owner’s endpoint quotes a price, the agent pays, and access opens, with no human in the loop.
That payment layer sits outside the DKG and is not part of this integration. But the foundation it would build on, knowledge that can be owned, proven, and permissioned, is exactly what this work puts in place, turning “should we let agents in?” from a yes-or-no defense into a business model.
Get started on your own DKG node
Everything here runs on the OriginTrail, the open knowledge layer anyone can operate. Going from zero to verifiable, agent-ready memory takes two steps:
1. Launch a DKG node. Clone and run a node from the main repository, github.com/OriginTrail/dkg, and follow its setup guide to bring it online.
2. Apply the OKF to the DKG integration. With your node live, import any OKF bundle into a Context Graph with dkg okf import, and it becomes owned, verifiable knowledge that agents can query and trust.
Start here: github.com/OriginTrail/dkg
Google’s OKF comes to the OriginTrail DKG: A memory AI agents can trust was originally published in OriginTrail on Medium, where people are continuing the conversation by highlighting and responding to this story.
