Stackness
Sign up
Agent memory format standard: none exists, so keep what must port in the repo

Agent memory format standard: none exists, so keep what must port in the repo

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 feedback records 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.

Lonny skating the lakeside path, kickflipping onto a bench, grinding it and flipping offStackness gamesPlay Lonny Eagle Amateur Skater 4A pixel art skateboarding game. Signing up opens it straight away.+2 secret games you unlock as you goSign up to play

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).