> First, answer me one thing—if an AI helps you write code but acts like it's meeting you for the first time every single time, is that what you want?
I spent a few days digging into a project called agentmemory. Founder Rohit says it gives AI coding assistants long-term memory. 3,400 stars on GitHub, built in two months. The numbers on the website are pretty: 95.2% retrieval accuracy, and costs of only $10 a year.
But after seeing enough so-called "breakthrough technologies," I've learned one lesson: pretty numbers don't prove anything. What matters is whether you can explain what this thing actually does in words a sixth-grader would understand.
So let's start from the beginning.
---
1. The Problem Itself: Why Does AI Need Long-Term Memory?
Imagine you have a coding partner. Very capable, but every time you approach him, he seems to have completely forgotten what you discussed last time. The bug you spent three hours fixing yesterday—today he asks: "What bug?" You spend half an hour explaining architectural decisions, and next time he says: "Oh, why didn't you tell me earlier?"
This is the real state of today's AI coding assistants—Cursor, Copilot, Claude Code. They have no memory. Or rather, their memory is limited to the context window of the current conversation.
Karpathy (former Tesla AI director, OpenAI founding member) wrote a note in April summarizing the problem in one line:
> Stop re-deriving, start compiling.
His point: today's AI has to "understand" you from scratch every time it meets you—your coding style, project structure, preference settings. It's like re-deriving the fundamental theorem of calculus before every exam. Why not keep a notebook? A "Wikipedia" the AI can just open and use.
That's the problem agentmemory wants to solve. Not making AI smarter, but making AI remember.
---
2. How Does agentmemory Solve It?
Rohit's approach works on several levels. Let me go from the bottom up.
1. Automatic capture: 12 "hooks"
Rohit says past memory systems required you to manually tell them "remember this." You'd have to mark things frame by frame: "remember I hate TypeScript," "remember this API's return format."
That's a problem. As Feynman might say: if something requires constant human effort, it will eventually be forgotten. People aren't machines; people get lazy.
So agentmemory built 12 "auto-capture hooks"—essentially instrumentation points. Commands you type in the terminal, tool calls, file edits—it records them all. No need to say "remember this"; it just remembers.
It sounds simple, but think about it: it means you don't need to change any habits. Keep working normally, and memory accumulates quietly in the background.
2. Retrieval: three methods searching simultaneously
Recording is only the first step. The key is how to find things again.
Think of your own brain. When you suddenly recall something, sometimes it's a keyword trigger ("I remember something called Docker"), sometimes a vague concept ("I remember a solution to a similar problem"), sometimes a concrete association ("Zhang San mentioned this in that meeting").
agentmemory mimics this. It retrieves in three ways simultaneously:
- BM25 — keyword matching, like a search engine
- Vector retrieval — semantic similarity, finding content that "means the same but uses different words"
- Knowledge graph — finding relationships between entities, e.g., "this file is related to that bug"
- Working memory — what's happening now, like the last command you ran
- Episodic memory — past events, like "we fixed that bug last Wednesday"
- Semantic memory — abstract knowledge, like "the project uses React, not Vue"
- Procedural memory — automated habits, like "the user always writes tests before code"
- LoCoMo: 91.6%
- LongMemEval: 93.4%
- BEAM(1M): 64.1%
- Paper A: 66.9%
- Paper B: 68.4%
- Mem0's own old algorithm: 71.4%
- Mem0's own new algorithm: 91.6%
- 12 auto-capture hooks solve the real problem that humans won't remember to tag things manually
- Triple retrieval (BM25 + vectors + knowledge graph) is a sound engineering decision
- Four-tier memory consolidation has cognitive science behind it, not guesswork
- $10/year cost makes it affordable for individual developers
- mem0's 81.4% in the comparison table is probably not current data
- The "92% token reduction" is against a strawman
- The benchmarks' inherent instability makes any precise claim of "95.2%" shaky
- Mem0's new algorithm has narrowed the gap to near-negligible
Then the three result sets are merged and ranked (RRF fusion), picking out the best for you.
3. Memory layering: organizing like a human brain
This is the design I find most interesting. agentmemory divides memory into four tiers:
The inspiration comes from how the human brain consolidates memory during sleep. The day's chaotic information gets organized and archived at night. agentmemory does something similar automatically—distilling scattered fragments into more durable knowledge.
4. The foundation: the iii engine
agentmemory is not built on the common Express.js + SQLite combo. It uses a runtime called the iii engine—new, written by Rohit himself. 51 MCP tools, 873 tests, plus a live viewer (port 3113) that can replay your sessions.
It's a bet. Either the iii engine becomes next-generation infrastructure, or agentmemory gets locked onto a runtime nobody maintains.
---
3. The Water in the Numbers: Is 95.2% Real?
OK, the architecture sounds good. But let's talk about the numbers.
The website has a comparison table:
| System | Accuracy | |--------|----------| | agentmemory | 95.2% | | mem0 | 81.4% | | Letta | 73.8% |
Pretty, right? But Feynman would ask: under what conditions were these numbers measured? Same questions, same judging criteria?
Let me lay out what I know.
Problem 1: What's the benchmark?
agentmemory claims 95.2% R@5 and 98.6% R@10 on LongMemEval-S (ICLR 2025, 500 questions).
But LongMemEval-S itself carries about 5% label noise—meaning some questions' "correct answers" may themselves be wrong. That means 95% is already near the theoretical ceiling.
Problem 2: Apples-to-apples?
That table puts agentmemory's 95.2% next to mem0's 81.4%. But—which version and configuration of mem0 produced that 81.4%?
Mem0 released a new algorithm in April 2026, scoring:
See? Mem0's new algorithm scores 93.4% on LongMemEval, not 81.4%. That 81.4% might be an old version, an old configuration, or a completely different benchmark.
It's like saying "my car is faster than yours" without saying whether the race was on a highway or a track.
Problem 3: The "92% token reduction"
agentmemory claims about 170K input tokens per year, versus 19.5M+ tokens for "full context pasting"—a 92% reduction.
But Feynman would ask: who actually pastes the full context every time?
This is a strawman argument. Nobody pastes "all context." Every system does some form of truncation or summarization. agentmemory's real comparison should be token consumption against other memory systems, not against an extreme approach nobody uses.
Problem 4: Wildly different numbers for the same system
This is the most telling fact to me.
Mem0's reported LoCoMo scores:
Same system, same benchmark, numbers jumping from 66% to 91%. Mem0's own blog says: "Scores have a ±1 confidence interval because judging criteria are inconsistent."
What does this show? The benchmarks themselves are unstable, and any precise claim of "95.2%" measured with such a wobbly ruler deserves a question mark.
Problem 5: The embedding model
agentmemory uses all-MiniLM-L6-v2—a lightweight model that runs locally, for free. That's good for cost. But it also means its embedding quality falls short of systems using GPT-4 or Claude for embeddings.
The direction is right (local, free, good enough), but it also means part of the numerical advantage comes from "achieving comparable results with cheap tools," not "my architecture is inherently superior."
---
4. Compared to the Alternatives, Where Does It Actually Win?
OK, the numbers have water in them. But that doesn't mean agentmemory is worthless. Let me lay out the competitors.
mem0: 51.8K stars, the veteran
mem0 is the most mature memory system today. But it has one fundamental difference: it requires you to explicitly call add().
That is, you have to write in your code: mem0.add("the user said they don't want popup notifications").
Feynman would say: if something requires an extra human step, humans will forget. agentmemory's automatic capture is genuinely better on this point.
But mem0's new algorithm has caught up. 93.4% vs 95.2%—the gap is now small. mem0 has a huge community, more resources, a more mature ecosystem.
Letta: the full agent runtime
Letta isn't just memory; it's a complete agent framework. But the price is lock-in—once you use Letta, your entire application architecture has to revolve around it.
The built-in option (CLAUDE.md)
Claude's CLAUDE.md file holds only 200 lines, and everything gets stuffed into context. Blunt and simple, but limited in scope.
agentmemory's real advantages
Not that 14-percentage-point gap. Rather:
1. Zero-config automatic capture — no code changes, no API calls, just work normally 2. Karpathy's philosophy — from "re-deriving every time" to "compile once, reuse forever" 3. Brain-inspired architecture — triple retrieval + four memory tiers, with real design thinking behind it
---
5. The iii Engine: A Bet or a Chain?
agentmemory is built on the iii engine—a brand-new runtime. Not Node.js, not Django—something Rohit built himself.
This reminds me of what Feynman saw in the Challenger investigation. NASA management's report put failure probability at 1/100,000. The engineers privately said it was 1/100. Management believed the numbers they wanted to believe.
The iii engine's problem: if Rohit stops maintaining it, or the community doesn't follow, what happens to agentmemory?
It's a real lock-in risk. But from another angle, the Express.js + SQLite + pm2 + Prometheus combo is itself aging. The iii engine might be a future-facing bet, or premature optimization.
I'm not sure right now. The only certainty: a two-month-old project on a brand-new runtime needs time to prove its reliability.
---
6. Growth Rate
Created at the end of February, now 3,400 stars. For a two-month-old project, that growth reflects genuine community interest, not fakery.
But stars aren't quality. Many good projects have no stars; many bad projects have piles of them. Stars only mean "someone found it interesting," not "this thing actually works well."
---
7. Final Verdict: Hype or Substance?
Feynman would say: I only believe what I can directly verify.
Let me be clear.
agentmemory's architecture has substance.
But those benchmark numbers have water in them.
agentmemory's value is that it turned Karpathy's philosophy into running code:
> Stop re-meeting me from scratch. Compile what you know about me, and load it directly next time.
The direction is right. Whether agentmemory ultimately wins or not, this direction is correct.
---
8. A Question Feynman Would Ask
Let me end the Feynman way.
If you deleted all the benchmark numbers, all the comparison tables, every "95.2%"—leaving only the code and architecture docs—would this project still have value?
My answer: yes. Auto-capture + triple retrieval + layered memory—these three things have genuine design depth on their own.
But if only the numbers and marketing copy remained, without the architecture?
That would be cargo culting. Bamboo control towers, coconut-shell headphones. All the forms correct, but the planes never come.
agentmemory is not cargo cult. It has real design. But those pretty numbers—95.2%, 98.6%, 92% reduction—apply a discount before you read them.
What really matters isn't how many points it beats others by. What really matters is that it gives AI assistants the ability to "remember" for the first time, without requiring you to do anything extra.
That's the way it is.
---
*Sources: agentmemory.dev, Karpathy gist (Apr 2026), Mem0 blog (Apr 2026), LongMemEval (ICLR 2025), LoCoMo benchmark*