Agent memory portability has become the test that separates a memory store from a company record. In one week, Graphon Labs raised $35 million to build persistent memory for agents, Redis made Agent Memory generally available, and a proposal that reached the Hacker News front page argued that the memory formats now in use cannot read each other. The money is moving into storage. The open question is whether what gets stored can move, be corrected, and still be trusted when a different tool reads it.
That question matters more than another point on a recall benchmark. A company does not run one agent. It runs an editor agent, a CI agent, a review bot, support agents and a growing set of vendor systems, each keeping notes in its own shape. If a lesson learned by one agent stays trapped in that agent, the company has not built memory. It has built several private notebooks that happen to sit on the same network.
The money moved into agent memory portability first
Graphon Labs announced a $35 million Series A on November 10, 2026, led by RRE Ventures, with HP, Energy Impact Partners, Hitachi Ventures and Gaia VC participating, putting total funding at $43.3 million including an $8.3 million seed announced on May 14, 2026. The company was founded in July 2025, so the Series A arrived a little over a year after founding and about six months after the seed.
Graphon calls its approach Persistent Intelligence. The platform ingests documents, video, images, audio and logs, builds a graph of how the pieces relate, and keeps links back to sources, rather than cutting content into chunks and retrieving the chunks in isolation. RRE general partner Raju Rishi stated the investor case in one sentence quoted by Unite.AI: "Models can reason, and agents can act, but neither gets better if they cannot build off of prior knowledge."
The company reports 81.7 percent accuracy on ATM-Bench, described as a University of Cambridge benchmark for question answering across video, audio, images and text, 5.0 percentage points ahead of the next system on the public leaderboard. Other coverage reports 94 percent on LoCoMo, while a separate report notes Graphon at 93.9 percent on LoCoMo in one place and 94.0 percent on its own site, with no independent replication seen. Those figures are company reported benchmark results. They test recall on prepared tasks. They do not test what happens when the memory has to leave the system that wrote it.
Redis moved the same week from the infrastructure side. On November 4, 2026, Redis announced the next chapter of Redis Iris, with Agent Memory generally available: it builds memories from user actions, documents and other semi-structured data through MemoryETL, organizes them in hierarchies, and provides inspection, audit and provenance, with the ability to forget material that should not be kept, such as personally identifiable information. Intent Router, Agent Playbooks and Context Gateway are also generally available, while Lens and Agent Mesh remain in beta, on the same release.
Two different bets sit inside those announcements. Graphon bets that relationships are the memory. Redis bets that memory belongs inside a production runtime with audit and provenance attached. Both bets assume the memory stays useful over time. Neither announcement settles the format in which that memory can be read by a competing tool.
The formats cannot read each other
The clearest statement of the problem came from LoreKit, in a post titled "Agent memory needs its OpenTelemetry moment", discussed on Hacker News. A roundup of the week in agent memory noted that Anthropic published "The components of agent memory" on November 7 in that roundup dating, that the LoreKit case drew strong front page attention by counting four incompatible memory formats on a typical developer machine, and that Redis and MongoDB shipped memory storage in the same week.
LoreKit lists the starting inventory in its own words: an AGENTS.md or CLAUDE.md file in most repositories and Cursor rules in a few, an agent writing files to a /memories directory through the Anthropic memory tool, Copilot keeping facts about each repository on the GitHub side, and a memory MCP server keeping a JSONL knowledge graph. The post then states the result plainly: that is four different shapes, and none of them can read the others. A lesson a CI agent learns stays in whatever wrote it. The editor agent cannot read it, and neither can the next tool a team tries.
The comparison table in the same post shows why a simple file conversion will not close the gap. Instruction files hold a whole Markdown file, addressed by file path, and are forgotten never, only when a person edits the file. The Anthropic memory tool holds a file under /memories, addressed by a path the model picks, forgotten never unless the model deletes it. GitHub Copilot Memory holds a fact with code citations, addressed by one repository, and deleted after 28 days of no use. Letta holds a labeled context block with a character limit. Mem0 holds a fact extracted from messages, addressed by user, agent, run or app identifiers, with an optional expiration date. LangGraph BaseStore holds a JSON value addressed by a namespace tuple and a key, with an optional time to live. Graphiti and Zep hold a fact on a graph edge, invalidated rather than deleted, on two timelines.
These systems disagree on the unit, the address and the rule for forgetting. A conversion that moves the text and drops the address, the expiry rule or the timeline has not moved the memory. It has moved a quotation of the memory, with the conditions that made it safe to use stripped off.
LoreKit frames the missing piece as an agreement, not another tool. Before 2019, every observability vendor shipped its own agent, library and data format, and switching vendors meant instrumenting the code again. OpenTracing and OpenCensus merged into OpenTelemetry in 2019, and vendors agreed on a data model, semantic conventions, one protocol called OTLP, and shared reference implementations, while continuing to compete on storage, querying and analysis. The post notes that MCP and AGENTS.md both sit under the Linux Foundation Agentic AI Foundation, which gives agent standards a neutral home of the same kind.
What a portable record has to carry
Strip away the branding, LoreKit argues, and every format answers the same five questions in a different way: where a memory is true, what its identity is and whether a second write updates it or duplicates it, what it says, when it stops being true, and which version is current. The post adds one fork that a standard must record rather than settle: who wrote the memory. In instruction files the writer is a person. In the memory tool, Letta and LoreKit the writer is the model. In Mem0 and Graphiti a service extracts facts from the conversation. A reader who cannot see the writer cannot judge how much trust the record deserves.
The illustrative record in the post carries an envelope before the content: an identifier, an address with a level and a value, a key, a kind, a version number, a supersedes field naming the older record it replaces, a written_by field, a content type, a lifecycle with an expiry rule, and attributes for material such as a pull request or a CI run. The memory itself sits below the envelope in Markdown. Around that record, the proposed specification has three layers: shared conventions for address levels, kinds and attribute names, a contract of fixed operations such as write, read, list, search and archive exposed over MCP, and conformance tests that check that a record survives a round trip, that unknown attributes survive a rewrite, that expiry behaves as stated, and that a superseded record reads as superseded. Storage, ranking, embeddings and the user interface stay outside the specification, as the parts where tools should compete.
The post separates two problems that are often run together. Existing proposals mostly solve export. MacPaw Research Portable Memory is a .mem bundle with byte reproducible serialization, deletion tombstones and optional signing, and its authors state that it is not widely adopted yet. The Open Memory Protocol is an April 2026 draft for moving conversations and derived memories between platforms as a ZIP file with a manifest. Cognee COGX imports from Mem0, Letta and Zep. Live addressing is the second problem: when a CI job, an editor agent and a review bot work in the same repository at once, how do they read and write the same place and agree on what it means. Export without live addressing helps a team leave a vendor. It does not help the agents a team runs today share one record.
This is where a company record differs from a developer memory file, and where the argument in our pillar on how Jilu works starts from the same point by a different route. A developer memory holds a lesson for the next session. A company record holds a decision, a policy and a customer commitment that other people and other agents will act on. Portability for that record has to carry the source, the date, the superseded version and the approver, or the receiving tool inherits a statement with no way to check it. Our recent work on knowledge compilation makes the same demand of a compiled layer: a compiled fact keeps its quote and its source, or it cannot be corrected.
The counter argument: portable memory can carry error and attack further
The strongest objection is not that a standard is hard. It is that memory itself can do harm, and a shared format would spread that harm faster. LoreKit states the point directly: shared memory is a prompt injection channel, because anything an agent reads can steer it, and shared memory widens who gets to write it. The post argues that a specification should make that visible by recording who wrote each memory, allowing signatures, and letting a record point at the code it depends on, while stating that no format makes poisoning impossible.
The research record supports caution. A survey of agent memory products and controls, current to November 2, 2026, reports that Microsoft 365 Copilot memory sits outside Purview retention and audit on Microsoft own documentation: retention policies and labels do not apply to it, memory actions generate no audit log entries, administrators cannot restrict what gets remembered, and deleting a chat does not delete the memories made from it. The same survey reports that Amazon Bedrock AgentCore Memory and Google Agent Platform Memory Bank were generally available on November 2, 2026, while memory in Microsoft Foundry Agent Service and Microsoft 365 Copilot memory were still in preview, and that its research found no shared record format among LangGraph, Mem0, Letta and the Anthropic and OpenAI API memory features, so moving memory between products is a custom export.
Poisoning is not a theoretical cost. The same survey cites the MINJA research, which reports a 98.2 percent injection success rate with query only access, and notes that OWASP lists memory and context poisoning as ASI06. Our earlier long form on the memory tax reported the other side of the ledger: in the Memory Tax study, dedicated memory systems scored below plain retrieval in 90 of 99 head to head tests, which is why any portability claim has to be tested against retrieval over the raw record, not assumed. And our recent post on the memory trap showed how a benign note, written in scope, can be read later as a standing rule far outside that scope. Portability without a stated boundary moves the overgeneralization with the note.
LoreKit also names the weakness in its own analogy. Traces are append only. Memories get corrected. A span is written once and never changes, while a runbook written in January gets corrected in March, and if nothing records the correction, both copies look right to the next agent. The post therefore treats the version rule as part of the standard: a counter that rises on every correction, and a link from the new record to the one it replaces. Without that rule, the lock in stays even if the formats line up.
The Portability Receipt Test
A buyer does not need to wait for a finished standard to test a memory product. Five checks, run on the company own records, settle whether agent memory portability is real in a given system.
First, the envelope test. Export one hundred records and read them outside the product. Each record should still carry its address and scope, its identifier, its source with a date, its writer, its lifecycle and expiry rule, and its supersedes link where a newer record replaced it. If the export is plain text with the envelope stripped, the product has an export button, not portability.
Second, the live addressing test. Have two different tools write to the same address on the same subject, one correcting the other. The second write should raise the version, name the record it supersedes, and leave the older record readable as superseded, not deleted and not competing as an equal. If both records return as current, shared access has created a conflict, not a record.
Third, the correction propagation test. Correct a fact that a summary, a standing instruction and a queued agent action were built from. The correction should reach the derived summary, change the standing instruction, and stop or amend the queued action. A memory that moves between tools but leaves its corrections behind in the first tool will export its errors at the same speed as its facts.
Fourth, the erasure round trip test. Delete one person records at the source, then export and reimport the store. The deleted material should stay deleted, with a tombstone where the format supports one, and it should not reappear as a summary, a reflection or an extracted fact in the receiving system. The Copilot retention gap reported above shows why this test cannot be skipped: in at least one major product, deleting the conversation leaves the memory in place by design.
Fifth, the trust label test. Mix records written by a person, written by a model, and extracted by a service, then ask the receiving tool to show which is which before it uses any of them. A system that flattens all three into one confidence level has removed the information a reviewer needs most. Procedural records, the ones that change how an agent behaves for everyone in scope, should pass a review gate before they travel, for the same reason they should pass one before they are promoted at home.
What this means for the company brain
The category is splitting into two questions that marketing runs together. Can an agent remember? The Graphon raise, the Redis release and the Anthropic memory research all say that storing and retrieving learned material is now a funded, shipping capability. Can a company keep that memory as one record, readable by the tools it chooses, correctable in one place, and deletable in full? That second question is the company brain question, and it is still open.
A standard, if it arrives, will not answer it on its own. MCP standardized the call, not the record, as the LoreKit post puts it. A shared envelope would make the record movable. Governance makes it trustworthy: a draft, review and publish gate before a note becomes a standing record, a named approver when sources conflict, the superseded version kept visible, and a correction path that reaches every copy and every action built from the original. Teams that hold that line can adopt a standard when it lands and change tools without losing the record. Teams that do not will discover that portability, when it comes, moves a private notebook collection into a shared one, errors included, at production speed.