· Source: Elvis Saravia (DAIR.AI) on LinkedIn, on Fu, Qi et al., "Can LLM Agents Organize Their Own Memory?", City University of Hong Kong and Tencent Jarvis Lab, arXiv 2611.11929 (2026-11-09). Code: github.com/Qi202/SoMem.
TL;DR
Most agent memory systems fix a schema up front (record types, grouping rules, fact/episode/profile buckets). SoMem drops the schema. The agent writes and revises ordinary Markdown topic documents, every paragraph footnoted back to the raw interaction it came from, and a deterministic runtime validates each edit and builds time, link and recency views on top. The design rule is "the model owns the meaning, code owns the consistency." On LoCoMo, BEAM-100K and LongMemEval-S it beats the strongest baseline by 2.0 to 3.1 points, and memory written by one model is readable by another. The catch is cost (about 34x Mem0 on a full LoCoMo run) and that the runtime guarantees structure and provenance, not that a summary still says what its source said.
The practical takeaway in the post: if your agent already reads and writes files, try letting it keep memory as linked notes before you add a vector store.
Architecture
Three stores, one validator, three derived views.
| Layer | Who writes it | What it holds |
|---|---|---|
| Source | Runtime, append-only | Raw interactions, immutable. The evidence. |
| Topic | The agent | Markdown docs it names, splits, merges and regroups. Each paragraph is a memory unit: stable ID, text, links to other paragraphs, footnote annotations with an event time (year/month/day precision as the source allows) and references to Source records. |
| Core | The agent, size-capped | Standing preferences, requirements and frequently needed background. Injected into every query like a system prompt. |
Validated edits. The agent stages every edit. The runtime checks that Source is untouched, the document structure parses, every evidence reference and link resolves, times are valid, paths are allowed, and Core is under its cap. Accepted edits are normalized, links broken by moves are repaired, and views are rebuilt. Rejected edits leave the previous state unchanged, so memory is transactional at the edit level.
Derived views, built by code.
Graph: paragraph links become a Relations index with outgoing links and backlinks.
Timeline:
timeline/YYYY/MM/DD.mdfiles, each entry pointing to its Topic paragraph and Source records.Recent: the K newest memory units, included in every query.
Maintenance. Periodic passes revisit Topic files changed since the last pass; an optional final pass reorganizes the whole collection. An optional probe asks a factual question about each new interaction and triggers a targeted repair if memory can't answer it, which is a cheap write-time recall test.
Reading. The agent starts with Core, Recent, a file inventory and the question date, then uses read-only tools (BM25, embedding search, list, read with line ranges; or a read-only shell with ls/find/rg/grep/cat/sed). There is no fixed retrieval pipeline. The agent searches iteratively and drops to Source when it needs to verify. Turn caps: 20 on LoCoMo, 50 elsewhere.
Results
GPT-6 Luna writes and reads, no reasoning effort; GPT-4o-mini judges at temperature 0.
| Benchmark | SoMem | Next best | Full context |
|---|---|---|---|
| LoCoMo accuracy (1,540 Qs) | 88.96 | E-mem 86.30 | 84.22 |
| BEAM-100K nugget score (400) | 54.02 | Full context 50.92 | 50.92 |
| BEAM-100K pass rate (400) | 61.50 | A-Mem 55.75 | 55.25 |
| LongMemEval-S accuracy (500) | 76.50 | LightMem 74.50 | 65.80 |
Strongest on temporal reasoning across all three (LoCoMo temporal 88.16 vs Mem0 82.24), which is what the footnoted event times and Timeline view are for.
Weak on BEAM abstention (23.75) and contradiction resolution (36.56 vs E-mem 51.56). A self-revising narrative tends to smooth contradictions over rather than flag them.
DeepSeek V4 Flash as writer and reader: 92.73 LoCoMo, 90.20 LongMemEval-S. BEAM-1M (10x longer histories): 69.29% pass under the 4o-mini judge, 84.14% under a stronger judge, a 15-point judge gap that says a lot about how soft these numbers are.
Writer and reader are separable: every writer/reader pair scores 90 to 93 on LoCoMo. Memory is a portable artifact, not tied to the model that built it.
More reasoning effort mostly helps, then plateaus. On BEAM, High to xHigh raised the score (59.07 to 61.79) while using fewer tokens, attributed to more targeted searching.
What the ablations actually say
Run on frozen LoCoMo memory, changing only what the reader can access:
Removing Source costs the most: -8.64 (CI -11.67 to -6.11). Summaries complement raw evidence; they don't replace it.
Removing Topic: -2.92 (CI -4.96 to -0.88).
Removing Core, Recent, Timeline or Graph: within 1.3 points, every CI includes zero. They shift which question types win rather than the total.
Against simple retrieval on a 100-question subset: SoMem 94, full context 89, adapted E-mem 81, adapted LightMem 75, one-shot BM25 64, one-shot dense 52. Agentic, iterative search over files is the big lever over single-shot retrieval.
Read plainly: the win comes from keeping the raw log and letting an agent search it iteratively, with agent-written topic notes as a modest index on top. The views are nice-to-haves on this benchmark.
Cost
Full LoCoMo run: $229.73 vs Mem0 $6.75, LightMem $6.46, A-Mem $35.19. $118.85 of that is one-time construction; queries are about $0.07 each.
66.3% of input tokens were cache hits; at 10% cached pricing the total falls to $96.33.
Per question: 5 to 7 model calls, about 20 seconds, final-call input about 18.6K tokens, 50K to 100K tokens total (up to about 200K on BEAM for Qwen).
This is an interactive-latency, frontier-model-budget design. It fits assistants with a few long-lived users, not high-QPS personalization.
Tradeoffs and failure modes
Semantic drift is unguarded. The validator proves each statement links to a real Source record; it cannot prove the statement still matches it. Repeated revisions can compound a paraphrase error while every link stays green. The authors list this as future work; commenters (Celso Sousa, Scott Campbell) raise exactly this.
Contradictions get absorbed. Weak contradiction and abstention scores suggest the agent rewrites toward one consistent story. If you need "the user said X on Monday and not-X on Friday," keep both and make conflict explicit.
Evaluation is soft. Uncalibrated LLM judges with no human agreement check, single-run ablations, small subsets for effort tests, QA over chat history only (no task execution, personalization or adversarial input).
Cost scales with writes. Construction and reorganization passes are the bulk of spend; frequent reorganization of a large corpus will dominate.
Core is a prompt-injection surface. Whatever the agent promotes into Core rides along on every query. A poisoned interaction that gets promoted persists.
Deployment gaps. No access control, retention or deletion story yet; sandboxed tools assumed.
Review checklist for an evidence-linked memory system
Is the raw log append-only and kept, not discarded after summarization? (The ablation says this is the biggest single factor.)
Does every derived statement carry a resolvable pointer to its evidence, and does the runtime reject edits that break it?
Are edits staged and atomic, with the previous state kept on failure?
Is there any semantic check of summary against source (periodic re-verification, write-time probe questions, or sampling with a judge)?
Are contradictions recorded as such, with both times, rather than overwritten?
Is the always-loaded layer (Core) size-capped and reviewed for injected instructions?
Can the reader verify by dropping to source, and does it within a turn budget?
Are cost and latency measured per write and per read, with cache hit rate?
Is memory model-portable, so writer and reader can be swapped?
Are results reported per question type (temporal, multi-hop, abstention, contradiction), not just overall?
Related entries
R040 WikiTrace: the closest cousin. Both keep the raw trajectory linked under every distilled lesson and let the agent descend to it; WikiTrace focuses on lessons from task runs and measures regressions, SoMem on conversational facts with agent-chosen structure.
R002 Five layers of agent memory: SoMem maps Source to episodic, Topic to semantic, Core to a mix of profile and procedural, and its maintenance passes are the GC/reflection step R002 says is usually missing.
R028 auto-ontology-mcp: the opposite bet, a typed checked schema with the model doing language steps. SoMem shares the split (model for meaning, code for checks) but lets the schema emerge.
R055 Relate: a graph database as memory; SoMem gets a graph as a derived view from Markdown links instead.
R036 Anthropic memory evals, R005 filesystem as long-term memory: same direction, files over vector stores.
R010 retrieval as navigation: SoMem's iterative read-then-follow-links beats one-shot BM25 and dense retrieval by 30 to 40 points on its subset.
Sources
LinkedIn post by Elvis S. (DAIR.AI), 2026-11-12: linkedin.com/posts/omarsar_super-interesting-work-on-agent-memory-share-7526654302363447296-jPf-/
DAIR.AI Academy summary: academy.dair.ai/papers/can-llm-agents-organize-their-own-memory-2611.11929
Paper: arxiv.org/abs/2611.11929
Code: github.com/Qi202/SoMem