Sometime around the end of June, the agent-memory field held an accidental debate. On June 29, Microsoft Research published Memora, a new memory representation with a paper, an MIT-licensed implementation, and a fistful of state-of-the-art numbers. Roughly twenty-four hours later, LangChain's Harrison Chase published Wiki Memory, a memory pattern with no benchmark at all. Neither post mentions the other. Read together, they stake out the two ends of a question the field has been avoiding: should you be able to read what your agent remembers?
Memora: memory you trust because it scores#
Memora's core idea is a split it calls a harmonic representation. The insight is that the thing you want to store and the thing you want to search are not the same object. So Memora keeps the rich content — full timelines, constraints, the texture of a conversation — in one place, and embeds only a compact layer for retrieval: short "primary abstractions" that capture the gist, plus cue anchors, which the paper describes as flexible, context-aware tags that give a memory more than one way to be found. Semantic search runs against the small abstractions; the detailed content is pulled only when a hit lands.
The payoff is measurable, and Memora measures it. On LoCoMo it reports 86.3% LLM-judge accuracy, against 82.5% for stuffing the full context into the prompt. On LongMemEval it reports 87.4%. It claims up to 98% fewer tokens than full-context inference, and — the number I find most telling — it stores about half the entries Mem0 does: 344 versus 651 per conversation. Fewer, denser, better-indexed memories, beating Mem0, Zep, Nemori, LangMem, and full context on the numbers the field has agreed to care about. The reference code runs on ChromaDB or Redis, so it slots into infrastructure you already run.
This is memory as a learned index. You don't read it. You trust it the way you trust a good embedding model: because it wins the eval.
Wiki Memory: memory you trust because you can read it#
Wiki Memory begins from the opposite instinct. Instead of compressing memory into an optimal representation, it has an agent maintain a wiki — a set of plain files that synthesize the raw source material into a higher-level map, kept up to date as new information arrives. The files are inspectable, editable, and versionable. The pattern's first real example is Cognition's DeepWiki, which auto-generates readable documentation for a codebase so humans and coding agents share the same mental model.
The move here isn't retrieval at all; it's precomputation. A wiki front-loads the synthesis so the agent doesn't rediscover structure on every query — the same reason a good README beats grepping the source each time you open a repo. But the load-bearing property is the one that never shows up in a benchmark: when the memory is wrong, you open a file and fix it. Or you diff it. Or you hand it to a colleague and ask why the agent thinks the deploy runs on Fridays.
Memora optimizes what the memory benchmarks measure. Wiki Memory optimizes what they don't. That's not a small gap — it's two different definitions of a working memory.
They're not on the same scoreboard#
The temptation is to ask which one is better and reach for the benchmark. But that quietly rigs the contest for Memora, because LoCoMo and LongMemEval score exactly one thing: did the system retrieve the right fact to answer the question. They have no axis for can a human tell why it retrieved that, and change it. If you rank these two frameworks by retrieval accuracy, you're not comparing them — you're grading Wiki Memory on a test it wasn't sitting.
This is the vector-database-versus-filesystem argument reincarnated one level up. A vector store gives you fast, fuzzy recall you can't easily read; a filesystem gives you legible state you have to search the slow way. Memora is the most sophisticated version yet of the first bet — it makes the opaque index cheaper and more accurate. Wiki Memory is the purest version of the second — it throws away the index and keeps the readable artifact. And notably, the "just use files" camp is gaining mindshare at the exact moment the benchmark-optimal camp is posting its best-ever LongMemEval and LoCoMo scores. That's not a coincidence; it's builders discovering that a memory that scores 87% is still a memory you can't debug at 3 a.m.
So the useful question isn't which framework remembers better. Every framework in this space — Mem0, Zep, Letta, now Memora — is a bet on compression, and compression is lossy in ways a recall score won't surface. The question Memora and Wiki Memory actually put to you is the one you should have been asking of all of them: when your agent remembers something wrong — and it will — which representation lets you find the bad memory and fix it? If your honest answer is "the one with the higher benchmark," you haven't had it remember something wrong yet.
