Everyone Is Building Agent Memory Now. Here's What the Wave Actually Proves.

Open Hacker News on any given week this month and you'll find another one: a new tool promising to give your AI agent a memory. This week our research scan caught three at once: Agent Recall, a Python knowledge-graph layer; Sediment, a Rust single binary; and Mimirs, a local MCP server for codebase memory. Earlier in the month it was Zero-Mem (101 points, Aug 5) and an SQLite-FTS5 MCP memory server (70 points, Aug 13). Before that, a weekly drip of "no-embedding" and "on-device" memory experiments.

When three independent builders ship the same category in the same week, something bigger is going on. A wave like this tells you two things: what the market has decided, and what everyone is still avoiding.

What the wave has decided

Strip away the different READMEs and every serious entrant this month converged on the same three choices:

1. SQLite as the storage layer. Not Postgres, not a managed cloud. One file, zero ops.
2. Local-first as the default posture. Your memories live on your machine, not behind someone's API.
3. MCP as the distribution channel. The tool doesn't ship with its own app; it plugs into Claude Code, Cursor, whatever agent you already run.

Six months ago this was a contrarian bet. Uteke was built on exactly this stack (SQLite, embedded vectors, local ONNX embeddings, an MCP server), and early on the common objection was "why bother with a local file when cloud vector DBs exist?" Now it's the category default. Independent builders don't coordinate, so convergence like this is the market voting.

Incumbents noticed too. The big general-purpose layers (Mem0 at 64K+ stars, Letta at 24K+) are enterprise-flavored and cloud-leaning. The new wave is the developer-native counter-current: small, single-binary, agent-first. Both can be true at once, but the energy and the weekly Show HN launches are all on the local side.

What the wave doesn't solve

"Local + SQLite + MCP" is now table stakes. It gets you into the category; it doesn't differentiate you inside it. The hard problems are still open, and most of the new entrants punt on all of them:

• Provenance. When your agent recalls a "fact," where did it come from? A URL? A file? Which agent wrote it? Most memory layers store content and lose the receipt. Once an agent acts on a recalled fact, unattributed memory is a liability.
• Consolidation. Agents re-remember things constantly. Without dedup and merge, a memory layer degrades into a junk drawer of near-duplicates: slower recall, staler answers.
• Multi-agent reality. Real workflows have several agents (or agents plus humans) writing to the same knowledge base. Flat user_id schemas make every fact single-player.
• Search quality. Keyword-only recall misses meaning; vector-only recall misses exact terms. If your memory layer can't do both and fuse them, your agent will confidently recall the wrong thing.

This is the filter to apply to every launch in this wave. "Is it local?" is a settled question. Ask instead: what happens to a fact after it's stored?

The honest scorecard

Sediment deserves credit for publishing its own benchmarks (Recall@1, dedup rate, store latency), and that transparency is good for the whole category. Agent Recall's scope hierarchies solve a real problem for agencies running many client contexts. Mimirs targets codebase memory specifically. These are real tools solving real slices.

The wave makes the category easier to explain and easier to trust. What it hasn't produced yet is a tool that combines the simple thesis (one binary, offline, no keys) with the operational depth (provenance, consolidation, multi-agent rooms, fused search) in one package. That combination is the actual frontier, and it's where we've spent our builds. Uteke is our open-source (Apache-2.0) take: a single Rust binary with source citations on every memory, near-duplicate consolidation, multi-agent rooms with author attribution, and hybrid fusion search (vector + full-text, merged). Recall runs at ~45ms, fully offline, MCP-ready.

We don't win every column, and that's fine. The interesting question has moved: six months ago it was "should agent memory be local?" Now it's "what does your memory layer do after day one?"

The takeaway

If you're evaluating memory tools in this wave, score them on the boring parts:

1. Citations. Can every recalled fact show its source?
2. Consolidation. Does it merge duplicates or hoard them?
3. Multi-agent. Can two agents share a memory without sync scripts?
4. Search. Semantic AND keyword, fused, not either/or.

The wave settled the thesis. The next six months are about operations. Choose the memory layer you could still trust a year from now.

Try it: Uteke on GitHub. One binary, zero dependencies, ~45ms recall, works with any MCP-capable agent.