The bug in the ecosystem

Run this thought experiment. Your agent has been in production for a year. It has accumulated thousands of memories: user preferences, resolved decisions, corrections, domain facts. Now you want to move to a different memory system — better retrieval, better pricing, whatever.

What's your migration path?

For most of the ecosystem: there isn't one. Hosted memory services keep your data in their cloud with no portability to other systems. Graph-based systems store memories in proprietary structures that can't be exported to anything else. Runtime-based systems own your whole agent loop, so leaving means rewriting the agent, not just the storage. The switching cost isn't an accident — for some of these products, it is the retention strategy.

We've all debugged this class of problem before. It's the pre-SMTP email problem. The pre-USB peripheral problem. A collection of good products that can't interoperate isn't an ecosystem — it's a set of traps with different UX.

OKF: the boring spec we actually needed

In June, Google Cloud published Open Knowledge Format v0.1. The entire pitch fits in one sentence: agent knowledge as a directory of markdown files with YAML frontmatter, under a handful of shared conventions.

No schema registry. No runtime. No SDK. If you can cat a file, you can read a memory. If you can git clone, you can ship a knowledge base.

The clever part is what the spec doesn't do. It defines the interoperability surface — how files declare what they are — without defining a content model. It doesn't tell you what memory types exist or what your knowledge should look like. That restraint matters. Standards that try to model everyone's domain die in committee. Standards that ride on primitives everyone already has (markdown, git, text) propagate.

For agent memory specifically, plain files buy you things no proprietary store can:

• Diffability. git diff shows exactly what your agent learned between two commits.
• Reviewability. Memory changes can go through pull requests like code.
• Auditability. Regulated environment? Your agent's knowledge is inspectable by a human, not just queryable by a model.
• Durability. Markdown will outlive every vendor in this space, including us.

What we built: OKF as a first-class citizen in Memanto

Memanto is an open-source (MIT) companion memory agent — it runs alongside your other agents and manages their memories so they can stay on task. In v0.2.8, OKF became a native format, not an afterthought export.

Export your agent's memories as an OKF bundle:

bash

memanto memory export --okf

You get one markdown file per memory, YAML frontmatter for metadata, grouped by memory type. Human-readable top to bottom.

Keep the bundle continuously synced — so memory lives next to your code, in version control:

bash

memanto memory sync --okf

And import any OKF bundle — from Memanto, from another tool, from a hand-curated knowledge directory — into a working agent:

bash

memanto migrate <agent> --okf <path>

The design constraint we refused to compromise on: round trips are lossless. Everything Memanto tracks that the base spec doesn't model — temporal validity, provenance, recall stats — is preserved under a namespaced x_memanto block in the frontmatter, exactly the extension mechanism the format anticipates. Export out, import back, diff shows nothing. If an "export feature" drops data on the way out, it's not portability — it's a screenshot.

Practical wins this unlocks immediately: version-controlled memory with real history, memory bundles shared across tools and teammates, readable backups that don't require a running service to inspect, and git revert as a legitimate answer to "my agent learned something wrong."

"Doesn't easy export kill your moat?"

Fair question. Here's our answer: a tool that has to imprison your data to retain you is admitting it can't retain you on merit.

We'd rather be held to a higher bar, so we shipped the receipts in the same release. v0.2.8 includes public, reproducible benchmark suites in examples/benchmarks/: a live Memanto-vs-Mem0 head-to-head with pluggable adapters and a dashboard, and a multi-adapter retrieval comparison covering Mem0, Letta, Supermemory, Cognee, Zep/Graphiti, and a vector baseline against LoCoMo and MemoryAgentBench. Run them. Fork them. If something else wins for your workload, OKF export means you leave with everything you accumulated here.

That's the deal we think every memory system should be offering you. The ones that won't are telling you something.

The network-effect endgame

A format is only a standard if implementations show up — otherwise it's a PDF with ambitions. Every tool that speaks OKF makes the format more valuable for every other tool that does, and makes memory silos a little less defensible everywhere. That flywheel is worth being early on, because the end state is good for everyone shipping agents: memory accumulated anywhere, usable everywhere; tool choice driven by capability, not hostage math.

Agents are becoming infrastructure. The memory they accumulate is becoming one of the most valuable assets your systems produce. Insist on owning it now, in a format you can read, diff, and take anywhere — or plan on negotiating it back from a vendor later.

Try it:

bash

pip install memanto
# or
npm install @moorcheh-ai/memanto

Docs: docs.memanto.ai · Changelog: v0.2.7...v0.2.8 · Benchmarks: examples/benchmarks/ in the repo.

Your agents focus. Memanto remembers.