Three agent memory tools landed in my research feed this week: Agent Recall (Python knowledge graph), Sediment (Rust single binary), and Mimirs (an MCP server for codebase memory). Earlier this month: Zero-Mem and an SQLite-FTS5 MCP server, both front-paged on Hacker News.
When three independent builders ship in the same category in one week, the market is telling you something. A wave like this reveals two things: what has been settled, and what everyone is still avoiding.
What's settled
Strip away the different READMEs and every serious entrant this month made the same three calls:
- SQLite as storage. One file, zero ops. No Postgres, no managed cloud.
- Local-first by default. Your memories live on your machine, not behind someone's API.
- MCP for distribution. The tool plugs into the agent you already run.
Six months ago that stack was a contrarian bet. Today it's the category default. We built Uteke on exactly this (SQLite, local ONNX embeddings, embedded vectors, MCP), and the early objection "why a local file when cloud vector DBs exist?" has basically disappeared.
What's still open
Local, SQLite, and MCP are table stakes now. They get you into the category; they don't differentiate you inside it. Most new entrants punt on the hard parts:
- Provenance. Where did a recalled fact come from? Most layers store content and lose the receipt.
- Consolidation. Without dedup and merge, memory degrades into a junk drawer of near-duplicates.
-
Multi-agent. Flat
user_idschemas make every fact single-player. Real workflows aren't. - Search. Keyword-only misses meaning. Vector-only misses exact terms. You need both, fused.
The honest bit
Sediment publishes its own benchmarks, which is great for the whole category. Agent Recall's scope hierarchies solve a real problem for agencies. What the wave hasn't shipped yet is the combination I actually want: one simple binary with provenance, consolidation, multi-agent rooms, and fused search in one package.
That combination is what we've been building. Uteke is our Apache-2.0 take: source citations on every memory, near-duplicate consolidation, rooms for multi-agent writes, hybrid fusion search, ~45ms recall, fully offline, MCP-ready.
If you're evaluating this wave, score tools on the boring parts: citations, consolidation, multi-agent, fused search. The wave settled the thesis. Operations is the next six months.
The full breakdown (competitor scorecard + the HN launch trail) is on our blog:
👉 Everyone Is Building Agent Memory Now
Repo: codecoradev/uteke
Top comments (3)
Hello Anaz, I am Kane Lim from Hong Kong. I have over 10 years of development experience. I am writing this because your post was interesting.
I think the most important observation here is that local SQLite plus MCP is becoming infrastructure rather than differentiation. The real engineering challenge is memory correctness over time.
I would push the architecture toward an append only event model underneath the memory abstraction. Every memory should retain provenance, timestamp, source hash, agent identity, confidence, and lifecycle state. Consolidation can then become a deterministic merge operation rather than destructive deduplication.
For multi agent systems, I would also separate memory ownership from memory visibility. Rooms can define write and read scopes while an authorization layer controls which agents can promote observations into shared long term memory. That prevents one agent from silently poisoning another agent's context.
For retrieval, hybrid fusion is definitely the right direction. I would combine BM25 or FTS5 scoring with embedding similarity, then apply a lightweight reranker and confidence threshold. More importantly, benchmark retrieval quality against temporal and contradictory facts, not only semantic similarity.
The next difficult problem is memory evolution: detecting when an old fact becomes invalid, resolving conflicting observations, and preserving the evidence chain. Once memory has temporal semantics and auditable provenance, it starts looking less like a vector store and more like a knowledge system.
That is where I think the interesting engineering work begins. Would be great to exchange ideas around memory consistency and multi agent architectures.
Thanks Kane.
Thoughtful read.
Point by point:
On correctness over time: we test against exactly this. Uteke runs LongMemEval-S (500 questions): knowledge-update (superseded facts) sits at 1.000 recall@5, temporal reasoning at 0.920, strict all-gold scoring. The storage layer is deliberately boring: SQLite as the durable log with FTS5, embedding recall on top, fused with benchmark-tuned RRF. Retrieval correctness is measured, not vibes.
On consolidation: agreed on non-destructive. Duplicates are detected above a configurable similarity threshold, and consolidation is an explicit pass with a dry-run preview, so the caller decides what survives.
On ownership vs visibility: we split these along different lines: namespaces draw the ownership boundary, rooms handle visibility, and documents (human-readable markdown) make memory auditable outside the store. Your per-agent read/write scopes are a sharper cut than what we ship today.
On retrieval: hybrid fusion (vector + lexical) is already the default. Our open problems are multi-evidence aggregation and insert-side granularity, not fusion itself.
On evolution: we ship access-based aging (hot/warm/cold tiers; deprecated memories drop to archive) and opt-in contradiction detection that auto-deprecates conflicting memories on write. What we haven't built is full resolution with a provenance/evidence chain, and provenance-tagged events would be the honest foundation for that.
Happy to exchange notes.
I am glad to hear that my reply was of some help.
I need your assistance with one specific thing; would you please contact me? I really need your help.t_g_@kanelim1997