Your Agent's Memory Shouldn't Die With Your Vendor

There's a question every developer building with agent memory eventually asks, usually around month three of a project, usually at an inconvenient hour: where do my memories actually live, and what happens if I need them somewhere else?

For most of the ecosystem, the honest answer is uncomfortable. Your memories live in a proprietary vector store, or a hosted knowledge graph with no export path, or a runtime that owns your entire agent loop. The knowledge your agents have painstakingly accumulated — user preferences, project facts, decisions, corrections, the slow sediment of every session — is locked to the surface that created it. Switch tools and you start from zero. Your agent gets amnesia because you changed vendors.

We think that's backwards. Memory belongs to you, not to whoever happens to be storing it this quarter. That conviction is why Memanto v0.2.8 ships with native, lossless support for the Open Knowledge Format — and why we believe format standardization is the most important thing happening in agentic memory right now.

The interoperability problem nobody planned for

The agent ecosystem grew up fast and messy. Every memory system invented its own storage shape: one embeds everything into a vector database, another builds a temporal knowledge graph, a third scatters facts across user, session, and agent scopes with its own extraction pipeline. Each shape is defensible on its own terms. None of them talk to each other.

The consequences compound quietly. Memories written by one system can't be read by another without a bespoke migration script that somebody has to write, test, and maintain. Teams running multiple agents across multiple frameworks end up with fragmented, contradictory memory silos. And the deeper a system's proprietary structure, the higher the switching cost — which, not coincidentally, is often the business model. Researchers have started naming this directly: hosted memory services create a new form of vendor lock-in, with proprietary graph structures that cannot be exported to other systems at all.

This isn't a hypothetical concern. It's the same movie the industry has watched before. Email was a walled garden until SMTP. Documents were format hostages until open standards forced the issue. Container orchestration was a vendor knife-fight until a common runtime spec ended it. In every case, the pattern was identical: the ecosystem couldn't mature until the data became portable, because portability is what turns a collection of competing products into an actual market.

“Agent memory is at that inflection point now.

Then Google put a stake in the ground

In June, Google Cloud published the Open Knowledge Format (OKF) v0.1 — a vendor-neutral, open specification for representing agent knowledge as a directory of markdown files with YAML frontmatter. No schema registry, no runtime, no required SDK. If you can cat a file, you can read it. If you can git clone a repo, you can ship it.

What makes OKF interesting isn't technical ambition — it's technical restraint. The spec formalizes what good teams were already doing ad hoc: keeping agent knowledge as human-readable markdown that travels in version control. Its design principle is that it defines the interoperability surface, not the content model. It tells you a file must declare a type; it doesn't presume to model your domain for you. That's precisely the kind of minimalism that lets a format win. Heavyweight standards die in committee. A one-page spec that rides on markdown and git can actually propagate.

And critically, OKF answers the question that proprietary memory stores never could: what does agent knowledge look like when no single vendor owns it? It looks like plain files. Diffable, reviewable, forkable, auditable. Readable by an agent and by the human responsible for that agent — which, for anyone operating in a regulated environment, is not a nice-to-have. It's the difference between memory you can govern and memory you have to trust.

What we shipped in v0.2.8

Memanto is a companion memory agent — it works alongside your other agents and manages their memories so they can stay focused on the task. That job description implies an obligation: a companion that manages your memories but won't hand them back isn't a companion, it's a captor. So OKF support in v0.2.8 was designed around one non-negotiable property: lossless round trips.

memanto memory export --okf writes your agent's memories as an OKF bundle — one markdown file per memory, YAML frontmatter carrying the metadata, grouped by memory type. Everything Memanto knows that the base spec doesn't model — temporal validity, provenance, recall statistics — is preserved under a namespaced x_memanto block, exactly the extension pattern the format anticipates. Export out, import back, nothing lost.

memanto memory sync --okf keeps a bundle continuously up to date, which means your agent's memory can live where your code lives: in a git repository, with history, diffs, and pull-request review. Your agent learned something wrong last Tuesday? git log will show you the exact moment, and git revert will fix it. Memory becomes an artifact you can operate, not a black box you can only query.

And memanto migrate <agent> --okf <path> closes the loop in the other direction: any OKF bundle — whether it came from Memanto, another tool, or a hand-curated knowledge directory — can be imported as a working memory set. Your memories from one ecosystem become the starting knowledge of an agent in another.

bashmemanto memory export --okf ./memory-bundle
memanto memory sync --okf ./memory-bundle
memanto migrate <agent> --okf ./memory-bundle

Three commands. But together they change the relationship between you and your memory system. Exit is now a first-class feature.

Why an open-source memory agent bets on open formats

There's an obvious question here: doesn't easy export undermine our own moat?

We'd flip it around. A tool that has to imprison your data to keep you is admitting it can't keep you on merit. Memanto is MIT-licensed and our benchmarks are public — this release also ships reproducible benchmark suites in examples/benchmarks/, including a live head-to-head against Mem0 and a multi-adapter retrieval comparison across Mem0, Letta, Supermemory, Cognee, and Zep/Graphiti on LoCoMo and MemoryAgentBench. Run them yourself. Fork them. If another system serves your agents better, OKF export means you can leave with everything. We think that bar — be worth staying for — is the right one to be held to, and we think the systems that refuse to be held to it are telling you something.

There's also a larger, less self-interested reason. Standards only become standards if implementations show up. A specification with no producers and no consumers is a PDF. Every tool that speaks OKF natively makes the format more valuable for every other tool that does — and makes memory silos a little less defensible everywhere. We want to be early on the right side of that network effect, because the endgame benefits everyone building agents: a world where memory accumulated anywhere is usable everywhere, where switching tools is a decision about capability instead of a hostage negotiation, and where the knowledge your agents build up over years is an asset you own outright.

The stakes get higher from here

Agents are moving from toys to infrastructure. The memories they accumulate are becoming genuinely valuable — years of organizational knowledge, user context, and learned behavior. The longer that accumulation runs inside closed formats, the more painful the eventual reckoning. The teams who insist on portable memory now are the ones who won't be renegotiating their own data back from a vendor in 2028.

OKF v0.1 is a starting point, not a finished standard, and it will only earn its name if enough tools speak it. As of v0.2.8, Memanto does — fluently, losslessly, in both directions.

“Your agents focus. Memanto remembers. And now, whatever it remembers is yours to take anywhere.

Get Started

• Install: pip install memanto or npm install @moorcheh-ai/memanto
• Read the docs: docs.memanto.ai
• Full changelog: v0.2.7…v0.2.8