The idea in one line
Google Cloud shipped a knowledge format on 2026-06-12 whose only hard requirement is a single type field. Our persona and document exports already meet it. That coincidence is worth understanding, because it hands us a portable, agent-readable way to share what we know without shipping how we know it.
Three layers that compose, not three tools that compete. One builds the knowledge, one carries it in a portable file, one runs the transforms over it. The value we protect never has to leave our side.
Three layers
Nouns, container, verbs. Each does one job.
myKG
Two-pass pipeline: induces an ontology from a corpus, extracts confidence-scored typed instances. The producer and the typed store.
OKF
A folder of markdown concept files with YAML frontmatter. The portable Layer-2 snapshot other agents and teammates read.
dotprompt
Executable prompt files with typed input and output. The transforms that keep a bundle current. Already in production in our module gallery.
OKF is the nouns
State that flows in and out. One markdown file per concept, one required field (type), a resource pointer to the live system behind it, and plain-markdown links between concepts. Vendor-neutral. If you can read a file you can read it; if you can clone a repo you can ship it.
dotprompt is the verbs
A .prompt file with an input schema, an output schema, and a templated body. It encodes how to generate something, not what is known. A dotprompt input is the socket an OKF record plugs into; its output writes records back. We already run these as report modules.
Why it is safe to share
This is the part worth internalizing. The firewall is not the format hiding a payload.
OKF encrypts nothing and access-controls nothing. It would be a mistake to think a bundle is safe because the format locks it. Protection is three separate things stacked, and each one is real on its own.
- The format is too poor to carry the alpha. OKF links carry no relationship type; meaning lives in prose. Our typed edges and second-order dynamics cannot pass through the envelope even by accident. A bundle is Layer 2 by construction.
- A deliberate export projection. We choose which types ship, we control what the prose bodies are allowed to say, and we allow-list which extension keys go out. The body describes what a document is; it never re-derives the analysis.
- A gated rehydration endpoint. The
resourcepointer resolves the deep model only for an authorized agent, through an endpoint we build and secure. The bundle carries the pointer, not the payload.
Said plainly: the format omits, it does not hide. That is exactly the property we want. We can hand a bundle to a partner's agent and it reads the shape of what we know, while the craft that produced it stays home.
The Fiserv proof
Not a slide. A real run on a real client corpus, done this week.
We pointed the mirror at the Fiserv documents. Every document now has an OKF concept beside it. The source documents were never touched, and each concept points back at its original.
It passed the public OKF validator with zero blocking errors. It is idempotent: a second run rewrites nothing, and only a changed document regenerates its concept. It is folded into the live Fiserv Prosperity dashboard, so the document layer sits next to the persona it describes.
The whole bundle is also browsable as a single self-contained graph: 49 concepts colored by type, linked by shared tags, with a filter and a detail panel. It opens offline and makes no network request. Open the interactive OKF graph →
The two-pass producer
The same shape as Google's own OKF reference producer: draft mechanically, then enrich.
43 structured docs, no model call
Documents that already carry frontmatter map straight to OKF: promote the title and description, map the type, hash the source, write the pointer. Fast and free.
6 transcripts, enriched by a prompt
Raw transcripts had useless auto-descriptions, so an okf-concept.prompt dotprompt reads each one and writes a faithful statement of what it is and why it exists.
The difference the second pass makes, on one real transcript:
# tier 1, deterministic — the raw opening leaked in as the description description: "[0:00] Limore: Okay. [0:01] N Djavit: Hello. [0:08] Limore: What the…" # tier 2, after the dotprompt read the document description: "Raw transcript of a 2026-03-10 video call between Limore Shur, Nuri Djavit, and Joshua Siegel about next steps for the Fiserv engagement."
That is the thesis in one move: dotprompt (the verb) producing a better OKF record (the noun), staying at Layer 2 the whole time.
What this completes for the Totem Protocol
The Totem Protocol has been a design for encoding intent: an ontology, a schema, a grammar, and a rubric for a concept-space. It lacked a portable container and a working intake path. These pieces close that gap.
- myKG is the intake engine. Point it at a person's documents, induce their persona ontology, extract confidence-scored instances.
- OKF is the portable container. The export serializes to a bundle any external agent can read without our tools. The
resourcepointer is the depth throttle. - dotprompt is the operating layer. Modules consume concept records and write enriched ones back, so a persona stays maintained instead of frozen at first build.
The honest boundary: OKF does not carry the discourse grammar or the rubric. Those two pieces stay net-new Totem work. The envelope carries the nouns and the pointers. It does not carry the grammar or the scoring, and no amount of adoption changes that.
The verdict
Adopt OKF and dotprompt, both narrowly. dotprompt is not an open question; it is already the right primitive and already shipping. OKF we adopt as a one-directional export and serving layer we own both ends of. Not an internal store, not a database, not a bet that others emit it.
Effort is low. Our exports already satisfy the format's hard rules. Risk is bounded: if OKF ever dies, we lose a serializer, not a system.
We are not chasing a shiny thing. dotprompt was already in production. OKF standardizes what our pipeline already emits. The strategic payoff is the firewall property: a way to share value while keeping the way we make it invisible.
Roadmap
Google ships four OKF reference implementations. We map each to our own work. All four are done.
1 · Two-pass producer
The Fiserv mirror, above. Deterministic draft plus dotprompt enrichment. Live in the dashboard.
2 · Static visualiser
A single self-contained HTML file that renders the bundle as an interactive graph, no backend, no data egress. Open the live graph →
3 · Sample bundles
Three bundles proving three graph shapes: a stack-rank vertical, a Totem persona, a value-flow REA model. Open the bundles →
4 · Serving and firewall
A gated Worker that serves top-level concepts and pointers openly, and answers HTTP 401 when the deep model is requested without authorization. See the contrast →
Immediate next steps
- Refresh hook so the Fiserv mirror stays current on save or nightly.
- Roll the same tool to the other client folders; it is client-agnostic.
- Build the
totem://resolver — the production form of the rehydration gate the serving demo runs as a bearer-token Worker. - Fold the team-intake exports into the same OKF standard (the persona export shipped with demo 3).