Count the recollection formats on your machine
List all location your coding tools keep item they "remember". A representative setup today:
- an AGENTS.md or CLAUDE.md in most repos, and .cursor/rules/*.mdc in a few
- an delegate penning records to a /memories directory through Anthropic's recollection tool
- Copilot keeping facts concerning all repo on GitHub's side
- a recollection MCP server keeping a JSONL cognition graph
That's four distinct shapes, and none of them can peruse the others. A instruction your CI delegate learns stays in any wrote it. Your publishing company delegate can't peruse it, and neither can the next tool you try.
Each format is sensible on its own. Together, they rebuild the identical small idea again and again: a note an delegate remaining for its forthcoming self, stored at several address, true for a while.
And the catalog keeps growing. Browse r/ClaudeAI, r/LocalLLaMA or r/cursor and you'll discover a dependable stream of "I built a recollection tier for my agent" posts, all alongside its own storage, its own schema and its own MCP tools. That's fine evidence the issue is real: group keep hitting it seriously adequate to build something. But all new resolution adds one additional format that nothing alternatively can read. The issue isn't a missing tool. It's a missing agreement, and that lone comes from the community operating on it together.
I build one of these tools, LoreKit, which is open source. This isn't a throw that LoreKit has solved memory. Its format is one recommendation among several, alongside gaps of its own. The item is that this is the instant to concur on a shared shape, and that another site has already shown how.
We've seen this before
Before 2019, all observability vendor shipped its own agent, its own instrumentation archive and its own data format. Switching vendors meant instrumenting your code again. Two open projects, OpenTracing and OpenCensus, tried to fix that and contested alongside all another too.
In 2019 they merged into OpenTelemetry. What mattered was what the vendors accepted to halt competing on:
- A data model: what a span, a metric and a log document are.
- Semantic conventions: shared names akin service.name and http.*.
- A protocol: OTLP, one way to dispatch the data.
- Reference implementations: shared SDKs and the Collector.
Vendors kept competing on what they do alongside the data: storage, querying, analysis. Users device once. I activity alongside OpenTelemetry all day at Dash0, and that accord is why a entire ecosystem of tools can peruse all other's data.
Agent recollection is anywhere observability was before 2019. The timing is good: the formats are young adequate to change, and there's already a neutral residence for delegate standards. MCP and AGENTS.md the two sit under the Linux Foundation's Agentic AI Foundation.
A tour of the shapes
These alter quickly, so treat the particulars as a snapshot from delayed 2026.
| Family | Example | The component of memory | Addressed by | Forgetting |
|---|---|---|---|---|
| Instruction files | AGENTS.md, CLAUDE.md, Cursor .mdc rules | A entire Markdown file | File way (plus globs for Cursor) | Never. A individual edits it |
| Agent-managed files | Anthropic's recollection tool | A document under /memories | A way the example picks | Never, unless the example deletes it |
| Hosted repo facts | GitHub Copilot Memory | A fact alongside code citations | One repository | Deleted following 28 days unused |
| Context blocks | Letta center memory | A tagged obstacle alongside a character limit | A tag on an agent | Never. Always in context |
| Extracted facts | Mem0 | A fact the assistance extracts from messages | user_id / agent_id / run_id / app_id | Optional expiration date |
| Namespaced store | LangGraph BaseStore | A JSON value dict | A namespace tuple + key | Optional TTL, reset whenever the item is peruse (by default) |
| Knowledge graph | MCP citation recollection server | Entities, relations, observations | Entity name | Never |
| Temporal graph | Graphiti / Zep | A fact on a chart edge | Entities + edge | Facts are invalidated fairly than deleted, on two timelines |
| Addressed record | LoreKit | A document alongside a scope, key and lifecycle | A range cord + key | Never, unless a TTL is set |
A few of them got item correct that a shared spec should keep. Copilot Memory pairs citations you can inspect against the code alongside forgetting by default, although it's locked inner one product. LangGraph shows how small the center can be: put(namespace, key, value). Graphiti models period properly, alongside distinct timelines for whenever a fact was true and whenever it was recorded. And AGENTS.md shows that a plain document at a known way can rotate into a standard.
The proposals that already exist
Several group have started on this. MacPaw Research's Portable Memory is a .mem bundle alongside byte-reproducible serialization, deletion tombstones and optional signing; its authors say it isn't extensively adopted yet. The Open Memory Protocol is an April 2026 outline for moving conversations and the memories derived from them between platforms as a ZIP alongside a manifest. Cognee's COGX format imports from Mem0, Letta and Zep.
These mostly resolve export: moving one person's recollection from vendor A to vendor B. Coding tools additionally have a second, open problem: live addressing. When a CI job, an publishing company delegate and a assessment bot activity in the identical repo at once, how do they peruse and compose the same location and concur on what it means? A complete spec needs both.
Strip distant the branding and all format answers the identical four questions differently: where a recollection is true, what its character is (does a second compose update it or copy it?), what it says, and when it stops being true. Nobody disagrees that those matter. The tools lone differ on the answers, which is anywhere OpenTelemetry started too.
There's one genuine fork: who writes the memory. In education records it's a person. In the recollection tool, Letta and LoreKit, it's the model. In Mem0 and Graphiti, a assistance extracts facts from the conversation. A spec doesn't need to choice one. It needs to record which, so a audience knows how much to rely what it reads.
Here's approximately what one document could appearance akin as a file. It illustrates the data model; the site names aren't a proposal:
--- spec: agent-memory/0.1 id: 8f0c2a6e-4b1d-4c7a-9e2f-3a5b6c7d8e9f address: { level: repo, value: github.com/acme/checkout } key: tests-need-local-postgres kind: lesson written_by: { type: agent, name: claude-code } content_type: text/markdown lifecycle: { expires_at: null, extended_by: write } attributes: { vcs.pr: 482, ci.run_url: "https://ci.example/runs/123" } --- Integration tests neglect alongside `ECONNREFUSED 127.0.0.1:5432` unless Postgres is already running. Start it before `pnpm test`: docker create up -d db The test setup does not commencement it for you.
The frontmatter is the envelope: location and key say anywhere it's true, id is its identity, lifecycle says whenever it stops, and written_by answers the fork. The Markdown below it is the recollection itself, and content_type tells a audience how to treat it. Anything alternatively a tool needs goes in attributes, under a namespace another tools can ignore. The identical document serialises to JSON fair as well, for a tool that wants to dispatch it complete the wire.
Around that record, a spec would mirror OpenTelemetry's layers:
- Conventions: shared names for location levels (global, project, repo, branch, and any monorepos need), for kinds, and for trait namespaces (vcs.*, ci.*, agent.*), in one versioned registry.
- A contract: a few operations (write, read, list, search, archive) alongside fixed inputs and outputs, exposed complete MCP. Many recollection servers now recommendation an MCP interface, but all exposes distinct tools alongside distinct meanings.
- Conformance tests in location of a citation implementation: round-trip a document and inspect nothing was lost, inspect that unidentified attributes last a rewrite, inspect that expiry behaves as stated.
What stays out matters as much: storage, ranking, embeddings, the person interface. That's anywhere tools should compete. And the spec should live location neutral, not in LoreKit's repo or any sole vendor's.
What a skeptic would say
"You build a recollection tool, so of way you desire a norm shaped akin it." Fair. It's why LoreKit is one row in the array fairly than the template. If a shared spec looks different, LoreKit should clasp it anyway.
"MCP already is the standard." MCP standardises the call, not the record. OpenTelemetry needed a protocol and a data model. Memory needs the two too.
"Shared recollection is a prompt-injection channel." Yes. Anything an delegate says can steer it, and shared recollection widens who gets to compose it. A spec should create that visible: document who wrote all memory, authorize signatures (Portable Memory already does), and let a document item at the code it depends on so a audience can inspect whether that code changed. No format makes poisoning impossible.
"Another norm won't fix fragmentation." That's xkcd 927, and it's the strongest objection. My answer is OpenTelemetry's: accord came whenever existing projects merged, not whenever person added another one. The activity current is the same: obtain what the existing proposals and tools all got right, and concur on the parts they share.
Open questions
I don't cognize the answers to these, and I'd fairly activity them out in public:
- Which location levels? Monorepos desire a flat between repo and branch. Should levels be a fixed catalog or conventions?
- Should forgetting be the default? Copilot forgets by default, LoreKit doesn't, and LangGraph extends existence on read.
- Should a document item at the code it depends on? It's the finest safety against old memory, but it ties a document to a code host.
- Who should coordinate? A operating group, a foundation, or a outline spec group dispatch changes to?
If you build any of the tools in the table, or wrote among the proposals, I'd akin to difference notes. LoreKit's schema and on-disk format are MIT-licensed as one tangible input. To see genuine records, LoreKit's offline shop writes plain Markdown records you can open, grep and diff:
npx @lorekit/cli install Compare them alongside what your another tools write, and inform me what a shared format would need that none of them have yet.
