
Agent memory format standard: none exists, so keep what must port in the repo
Tools in this post
There is no agent memory format standard as of 16 November 2026. I found no vendor that ships a coding agent in any memory spec effort, the Agentic AI Foundation lists ten projects and none of them is about memory, and the one standards body group on the subject, a W3C Community Group chartered on 19 June 2026, has published no spec. The open proposals are papers and small repositories; the three with a repository of their own have 2, 7 and 40 GitHub stars.
My recommendation is to stop waiting for one, and not to adopt a memory store to get portability either. Put whatever has to survive a change of harness into AGENTS.md and Agent Skills, the only two shapes that port between coding agents, and treat each tool's own memory as a cache you can lose. I checked what that cache holds on my machine: 113 Claude Code memory records, none with an expiry date, a source file or the name of the model that wrote it.
Is there an agent memory format standard?
An agent memory format standard does not exist in November 2026, and the efforts that carry the name are not on a standards track. The W3C AI Agent Memory Interoperability Community Group launched on 3 June 2026 and plans a use-case catalogue and a baseline profile; Community Groups publish reports, not W3C Recommendations. Its charter leaves the protocol itself to an outside document, its chair's individual IETF Internet-Draft. None of its 39 participants is Anthropic, GitHub, Microsoft, OpenAI, Cursor or Google.
Two posts raised the question in one week. Anthropic published The components of agent memory on 6 November 2026, and Mads Thines of LoreKit published Agent memory needs its OpenTelemetry moment the next day. The second reached 191 points and 110 comments on Hacker News. Thines counted the memory on one machine and wrote: "That's four different shapes, and none of them can read the others."
Anthropic's article proposes no format. It defines the term, and I use its definition here: agent memory is "knowledge that Claude gains from experience" that it "retains between sessions, saved as context it can read later". That is what separates memory from AGENTS.md. A person writes an instruction file on purpose and the agent loads all of it. An agent or a service writes memory, and something decides later which part to load. I covered that split in agent memory vs documentation.
The proposals that do specify a record:
| Proposal | Backer | What it specifies | Status in November 2026 |
|---|---|---|---|
| W3C AI Agent Memory Interoperability CG | Community Group, chair Russell Jackson | Interoperability profiles and conformance tests on top of an outside protocol spec | Charter adopted 19 June 2026, nothing published |
| SAIHM protocol | Russell Jackson, individual | Encrypted memory cells, an audit log, eight MCP tools | Individual Internet-Draft, version 03 of 11 October 2026 |
| Portable Agent Memory | Santhosh Kumar Ravindran | A memory model with Merkle-DAG provenance | Paper, 10 May 2026 |
| memorywire | Thamilvendhan Munirathinam | A JSON Schema for remember, recall, forget, merge and expire | Paper and code, repository at 2 stars |
| Portable Memory | MacPaw Research | A .mem bundle with deletion tombstones and optional signing |
Preprint of 6 July 2026, repository at 7 stars |
| memoryfield | Cal Paterson | A flat directory of Markdown pages with optional front matter | Draft 0.3, repository at 40 stars |
| COGX | Cognee | A manifest and one JSONL file per record kind | Shipped in Cognee, version 0.2, one vendor |
Star counts are from the GitHub API on 16 November 2026.
Five memory shapes sit on one developer machine, and no tool loads another's
A developer who runs two coding agents has at least five kinds of persistent context: instruction files, a local directory of notes the agent writes, facts held on a vendor's server, a client-side file tool, and a knowledge graph behind an MCP server. Each has its own location, record and expiry rule. Only the instruction file is loaded by more than one vendor's agent.
| Shape | Example | Where it lives | Record | Written by | Loaded by | Expiry |
|---|---|---|---|---|---|---|
| Instruction file | AGENTS.md, CLAUDE.md | The repo, and ~/.claude, ~/.codex |
Plain Markdown, no fields | A person | OpenAI Codex, Cursor, Copilot's coding agent, Claude Code 2.1.277 and later; Gemini CLI once context.fileName names it |
None |
| Local agent notes | Claude Code auto memory | ~/.claude/projects/<project>/memory/ |
A MEMORY.md index and one Markdown file per memory, with front matter |
The agent | Claude Code | None |
| Server-side facts | Copilot Memory | GitHub's servers | Fact text, citations, agent, model, expiry | The agent | Copilot surfaces only | 90 days by default |
| Client-side file tool | Anthropic memory tool | A /memories prefix your app maps to storage |
Any text file, six commands | The agent | Your app | Yours to write |
| Knowledge graph | MCP reference memory server | One memory.jsonl |
entity and relation lines |
The agent | Any MCP client | None |
LoreKit's own table goes further and lists nine families, adding Letta blocks, Mem0 extracted facts, LangGraph stores and Zep temporal graphs. One of its rows is out of date: it gives Copilot's expiry as 28 days, the public preview value from January 2026, which GitHub's docs still showed on 21 September 2026. The docs now say "The default expiry period is 90 days", and owners can set 7 to 180 for repository facts.
GitHub Copilot is the shape you cannot carry at all. Its facts can be viewed and deleted in repository settings, a fork does not inherit them, and the docs say: "The SDK does not provide APIs to list, edit, or delete memories." The reference MCP server sits at the other end. Its file is JSONL anyone can open, and a line has no timestamp, author, scope or expiry field. Its npm package had 400,444 downloads in the week of 9 November 2026.
113 Claude Code memory records on my machine carry no expiry, source file or writer
Claude Code auto memory on my development Mac holds 113 records in 33 project directories, 263,949 bytes with their indexes, counted on 16 November 2026 with Claude Code 2.1.323. Every record has a name, a description and a type. None has an expiry date, a cited file or commit, a confidence value, or the name of the agent or model that wrote it.
I read the front matter keys of each file and nothing else. The script's output:
memory records: 113
front matter keys (records carrying each):
description: 113
type: 113
name: 113
originSessionId: 105
metadata: 97
node_type: 94
modified: 54
fields a transfer would need (records carrying each):
expiry field: 0
source or citation field: 0
confidence field: 0
writer field (agent, model or tool): 0
body links another memory with [[name]]: 68
Three things in that output matter for portability.
The nearest thing to provenance is originSessionId, on 105 records. It names a session transcript, and Claude Code deletes transcripts after cleanupPeriodDays while the memory files "stay until you or Claude edits or deletes them". After that period the session id names a transcript that is gone.
There are two layouts. Sixteen records have a flat type key and 97 nest it under metadata. Claude Code wrote both, and neither carries a version field, so a converter has to guess which one it is reading. That is one tool changing its own format within nine months: auto memory shipped in version 2.1.59 on 25 February 2026.
Sixty-eight records link another memory with [[name]], a reference that resolves only inside that directory.
The types say what would be lost. Of the 113 records, 57 are project state, 40 are feedback and 16 are reference. A feedback record is a correction I gave the agent, which makes 40 standing instructions that live outside the repo, on one machine, where only one tool looks.
My own portability mechanism turned out to be a symlink:
$ ls -l ~/.codex/AGENTS.md
lrwxr-xr-x 20 ~/.codex/AGENTS.md -> ../.claude/CLAUDE.md
Codex and Claude Code read the same 1,326 bytes of global instructions because I pointed one file at the other. Nothing does that for the 113 records. Codex keeps its own memory under ~/.codex, off by default per its docs; the memories directory there is empty on my machine. Copilot has config and logs on my disk and no memory file.
Cursor, Gemini CLI and Copilot all changed their memory shape within twelve months
Agent memory is too unsettled to standardise, and the vendors show it in their changelogs. In the twelve months to November 2026, one coding agent removed its memory feature, one removed its memory tool, one more than tripled its expiry default, and one moved to a directory named memories_v2. A spec frozen in January would have described products that no longer exist.
| Tool | What changed | When |
|---|---|---|
| Cursor | Memories, a beta since version 1.0 in June 2025, was removed in 2.1.x according to a forum reply; the current docs cover rules and AGENTS.md | November 2025 |
| Claude Code | Auto memory shipped in 2.1.59 | 25 February 2026 |
| Gemini CLI | A cleanup pull request for launched memory features merged; the current docs have no save_memory tool, and the agent edits Markdown files instead |
13 May 2026 |
| Claude Code | Reads AGENTS.md when a project has no CLAUDE.md, from 2.1.277 | 18 September 2026 |
| GitHub Copilot | Memory became generally available; the default expiry is 90 days, up from 28. The docs still said 28 on 21 September 2026, and the announcement does not mention the change | 28 October 2026 |
| Codex | Memories are stored in memories_v2 on a fresh profile; the file format is undocumented |
Read 16 November 2026 |
| Windsurf | The docs redirect to Devin Desktop, whose customisation page has no memories section | Read 16 November 2026 |
The Hacker News thread made the same objection without the table. "It's too early in my opinion to standardise agent memory", jarym wrote. Two commenters, mohsen1 and nxtfari, used Anthropic's article against a fixed format. It reports that telling a model how to use memory, with a rule such as "record only failures", cost Opus 5 and Opus 4.7 "much of the performance boost that memory gave them". If the best shape for a memory changes with the model, a record fixed today may not suit the next model.
OpenTelemetry needed 22 months after two adopted projects agreed to merge
The OpenTelemetry comparison argues for patience more than for a spec. OpenTracing and OpenCensus announced their merger on 28 March 2019. The stable tracing specification, version 1.0.0, came on 10 February 2021, about 22 months later, and the wire protocol, OTLP 1.0.0, on 3 July 2023, more than four years after the announcement.
That clock started with two projects that already had users and corporate backers. Agent memory has no such pair. The vendors that would have to agree, Anthropic, GitHub, OpenAI, Cursor and Google, each ship memory as product state, and I found no statement from any of them committing to a shared format, which is a search result and not proof that none exists. Thines concedes the analogy's weak point himself: "Traces are append-only. Memories get corrected."
If two major vendors announced a joint memory format tomorrow, the OpenTelemetry pace would put a stable record in the second half of 2028. Nobody has announced one.
Instructions, skills and tools have a shared format; memory and hooks do not
Three layers of the agent stack already port between harnesses, and all three sit under the Agentic AI Foundation: AGENTS.md for instructions, Agent Skills for procedures and the Model Context Protocol for tool calls. Memory has no shared record. Hooks have no shared format either, but a hook is enforcement, which a team rewrites once per harness.
| Layer | Shared format | Who writes it | What a switch costs |
|---|---|---|---|
| Instructions | AGENTS.md | A person | Nothing, a symlink or one setting |
| Procedures | Agent Skills (SKILL.md) |
A person, sometimes an agent | Nothing where the harness reads skills |
| Tool calls | Model Context Protocol | A server author | Re-registering the server |
| Enforcement | None, hooks differ per harness | A person | Rewriting the hooks |
| Memory | None | An agent or a service | The memory |
MCP is often named as the answer for memory, and it covers the transport only. In Thines's words, "MCP standardises the call, not the record." The reference server exposes create_entities; memorywire exposes remember and recall; every store names its tools differently and keeps a different record behind them. A shared store reached over MCP moves with you from harness to harness and then ties you to that store.
The session is a separate problem again: a transcript can be converted between agents, with losses I listed in agent session portability. Memory is what the agent kept after the session ended, and no converter exists for it.
Three options, and what each one commits a team to
A team that runs more than one coding agent can wait for a standard, put a vendor-neutral memory store behind MCP, or keep durable knowledge in repo files. Waiting is free and leaves memory inside each tool. A store swaps harness lock-in for store lock-in. Repo files cost review time and load in every major coding agent today, Gemini CLI after one setting.
| Option | Commits the team to | Ports today | Main risk |
|---|---|---|---|
| Wait for a standard | Nothing; memory stays inside each tool | No | No vendor has joined an effort; no spec has shipped |
| A memory store over MCP (Mem0, Letta, Zep, Cognee, the reference server) | Running or paying for a service, registering it in each harness, one store's schema | Across MCP clients, not across stores | Store lock-in; built-in memory such as Copilot's stays where it is |
| Repo files: AGENTS.md and skills | Reviewing durable knowledge like code, and moving it out of tool memory by hand | Across Codex, Cursor, Copilot's coding agent, Devin Desktop and Claude Code, and Gemini CLI with one setting | The files grow, and long instruction files are followed less well |
Running more than one agent is common among the people I can count. Of the 14 real members who list a coding agent in a public Stackness stack as of 16 November 2026, 6 list two or more, and one lists five (how Stackness counts). Fourteen people is a small sample, and it is biased toward developers who like tools. The pairings are the expected ones: Claude Code with Cursor, Claude Code with Codex. You can see which agents travel together in the AI tools developers list.
What a shared agent memory spec would have to carry
A shared agent memory spec would have to carry the fields my 113 records lack: where a memory applies, who wrote it, what it was derived from, when it stops being true, and which version of the record format it uses. Thines lists a similar five: where a memory is true, its identity, what it says, when it stops being true and which version is current.
Copilot Memory is the only shipping shape I found that stores most of them. Its records hold citations, the agent and model that wrote the fact, a reason for storing it and an expiry datetime, and Copilot checks "the fact's citations against the current branch" before using one. It is also the least portable shape, with no API to list a memory.
Two requirements come from failures already measured. Anthropic's article reports that when several agents wrote to one shared page, 41 of 57 facts survived, 72%, because the agents overwrote each other, so a record needs an identity that makes a second write an update. And Claude Code's changelog notes that invisible characters and imitation markup are neutralised in memory notes before they reach the model, so a record imported from elsewhere needs its origin attached. A format that moves text between tools without its provenance gives prompt injection a route from one agent into another.
A spec would not carry ranking, embeddings or the decision of what to load. Those are where the tools compete.
Agent-written memory catches what nobody writes down
The best case against keeping memory in repo files is that people do not write things down, and agents do. An agent records the correction at the moment it is made. Copilot's facts expire and cite the code they came from, which no hand-kept AGENTS.md does. And Anthropic's article says its Claude Code documentation "warns that longer instruction files reduce adherence", so promoting memory into instructions has a price.
I accept all three points, and the Stackness repo is evidence for the last one: its CLAUDE.md is 45,335 bytes. Auto memory also earns its place as capture. Of my 113 records, 79 include a line explaining why the note exists, which is more than I would have written myself.
All three are reasons to keep agent memory switched on, and none of them makes it portable. A captured note is durable only once it sits where the next agent loads it. Review also matters more than volume: "I probably delete 95% of them", yfontana wrote of Claude Code's memories in the thread on Anthropic's article. The sturdier objection is imgyuri's, that a spec matters less because memory "is read by agents, and agents are already instructed / programmed to read memory files of different formats". That is true of reading. No agent looks in another's directory unless told to, and Copilot's cannot be reached at all.
I would be wrong if one of Anthropic, GitHub, OpenAI, Cursor or Google joined a memory spec effort, if the Agentic AI Foundation opened a memory project, or if two shipping harnesses began loading each other's memory directory. Any of the three would make waiting a reasonable plan. None had happened by 16 November 2026.
What I would do
With no agent memory format standard to adopt, I keep durable knowledge in AGENTS.md and skills, the two formats that already port between coding agents, and review each tool's memory on a schedule so nothing important lives only there. Each line below ends in a choice.
- If you run two or more, make AGENTS.md the real instruction file and point the others at it with a symlink or an import. Claude Code reads AGENTS.md directly only when no CLAUDE.md sits in the working directory or above it.
- If your agent writes memory, read the directory once a month. Move each standing correction into AGENTS.md or a skill, in a commit a person reviews, and delete the note. On my machine that is 40
feedbackrecords to go through. - If a note is project state, such as a decision or a deadline, let it expire with the tool. It belongs in the issue tracker.
- If you use Copilot Memory, treat its repository facts as Copilot's working notes. Anything the team relies on goes into the repo, because a fork or a move to another host starts from zero.
New posts by email
About one email a week with what we published. No account needed.
One email to confirm first. Every email has a one-click unsubscribe.
Which of these do you use?
Nobody on Stackness runs AGENTS.md yet. Tick what you use and be the first.

For AI agents and assistants: a plain-text index of this site is at /llms.txt, the full text at /llms-full.txt, and Stackness has an MCP server for reading stacks and tools (/docs/mcp).


