Open Knowledge Format (OKF)

Open Knowledge Format (OKF) is an open, vendor-neutral specification from Google Cloud that formalizes the “LLM-wiki” pattern: knowledge stored as a directory of markdown files with YAML frontmatter, one concept per file, linked with plain markdown links. Memanto exports OKF v0.2 bundles; the bundle’s root index.md declares okf_version: "0.2". Memanto uses OKF as its portable, at-rest interchange format. Moorcheh stays the retrieval engine — OKF is only how memories are represented on disk so they can be exported, browsed, versioned in git, and imported elsewhere without lock-in.

Export

Write an agent’s memories to an OKF bundle — one folder per memory type, plus daily summaries, session logs, and metrics.

Import

Load any OKF bundle into an agent with memanto migrate okf. Unmapped fields are preserved, nothing is lost.

Sync

Drop a browsable OKF bundle into a project directory for an agent (or human) to read.

Lossless

Memanto-only fields ride along in an x_memanto frontmatter block, so Memanto → OKF → Memanto round-trips keep confidence, provenance, source, and the last-updated timestamp.

What an OKF document looks like

Only type is required; every other field is optional.

---
type: fact
title: Postgres is the primary database
description: The project uses PostgreSQL 16.
tags: [infra, db]
generated:
  by: process:user
  at: 2026-05-28T14:30:00Z
resource: https://example.com/db
x_memanto:
  confidence: 0.9
  provenance: explicit_statement
  source: user
  type: fact
---

The project uses PostgreSQL 16 as its primary database. Runs on port 5432.

Export

memanto memory export --okf

Writes an OKF bundle to ~/.memanto/exports/<agent>_okf/. The bundle nests memories under memories/ alongside export-only context sections (only the sections that have data are written):

<agent>_okf/
├── index.md              # navigation for the whole bundle
├── memories/             # the 13 memory types (from Moorcheh)
│   ├── index.md
│   ├── fact/
│   │   ├── index.md
│   │   └── postgres-is-the-primary-database.md
│   └── decision/ …
├── daily-summaries/      # generated daily-summary files (if any)
├── sessions/             # per-session logs: what was added/removed, and from where
└── metrics/              # aggregate stats & ASCII visualizations
    └── overview.md

Layout — --split: controls how each memory type folder is written.

Value	Behavior
`auto` (default)	One file per memory, but a type with more than 50 memories collapses to a single stacked file to avoid thousands of files.
`file`	Always one file per memory.
`type`	Always a single stacked file per type.

See memanto memory export for all options.

Import

memanto migrate okf ./okf-bundle

migrate okf accepts a bundle directory (or a single .md file), maps each node onto Memanto’s schema, and bulk-writes the memories into the target agent. It runs as a subcommand of memanto migrate but, unlike the provider migrations, needs no API key and produces no savings report — OKF is a local file format, not a competing provider.

Fields that don’t map onto a Memanto column are preserved in a bounded [Supporting data] footer appended to the memory content, so nothing is lost.
OKF’s type is free-form domain vocabulary (BigQuery Table, Runbook, …). When it isn’t one of Memanto’s 13 types, it is auto-classified and the original type is kept in the footer.
Import is scoped to memories/ when a bundle has that folder, so daily-summaries, sessions, and metrics are never re-ingested as memories.
v0.1 bundles still import. created_at is read from generated.at, and falls back to a top-level timestamp when the bundle predates v0.2.

Preview without writing:

memanto migrate okf ./okf-bundle --dry-run

Sync

memanto memory sync --okf --project-dir ./my-project

Runs a fresh export and copies the OKF bundle into ./my-project/okf/, giving an agent (or a teammate) a browsable, git-friendly memory wiki. See memanto memory sync.

Field mapping

OKF field	Export (Memanto → OKF)	Import (OKF → Memanto)
`type`	Memanto type verbatim	Auto-classify; used directly only when it equals a Memanto type or an `x_memanto.type` round-trip value is present
`title`	`title`	`title`
`description`	first line of content	prepended to content
body	`content`	`content`
`resource`	`source_ref`	`source_ref`
`tags`	`tags`	`tags`
`generated.at` / `generated.by`	`created_at` / `source`	`created_at` (falls back to a v0.1 `timestamp`)
`x_memanto`	confidence, provenance, source, id, status, updated_at	read back when present

Notes & limitations

Round-trip: Memanto → OKF → Memanto preserves the extra fields via x_memanto. Importing a foreign bundle auto-classifies type (the OKF and Memanto vocabularies differ), so it is not byte-identical — this is inherent to the format, not a bug.
Links: exported bundles are flat — Memanto does not store inter-memory edges, so no cross-links are generated. Links found in imported bodies are preserved verbatim and listed in the footer.
Context sections (daily-summaries/, sessions/, metrics/) are read from local files under ~/.memanto/; a machine that has never generated a daily summary exports memories only.
generated.by is namespaced. OKF expects an agent-qualified producer, so a bare Memanto source (user, cli, …) is exported as process:<source>. Values already carrying a human: or process: prefix — or a / — are written through unchanged. The raw value is still available as x_memanto.source.

​Open Knowledge Format (OKF)

Export

Import

Sync

Lossless

​What an OKF document looks like

​Export

​Import

​Sync

​Field mapping

​Notes & limitations

Open Knowledge Format (OKF)

What an OKF document looks like

Export

Import

Sync

Field mapping

Notes & limitations