The agent-memory landscape: where each tool actually sits

We built a memory product, so we had to understand the field honestly. Not with a “we win every row” table, but with a map of where each tool’s centre of gravity actually sits. Here it is.

The spectrum: developer-first to enterprise fleet

Lay the category out on one line, from indie and developer-first on the left to enterprise and fleet on the right, and the tools sort into rough clusters.

Supermemory, Mem0, Cognee (developer-first). Fast to adopt, broad, popular. Great for a single assistant or a solo builder. Temporal support is mostly marketing over one clock; isolation and write-path integrity are not the pitch.

Anthropic (the gravity well). Every Claude user gets managed memory with zero third parties, so many teams default here. Convenient, but self-building, and its injection mitigation is read-only: turn learning off. The gap it leaves open is security and neutrality.

Hunta Gather (us). Enterprise and fleet features: per-tenant isolation with a buyer-runnable proof, and an injection-hardened write path where a separate reviewer approves every write. Honest bi-temporal is on the way. We sit just left of Zep.

Zep (enterprise anchor). The deepest temporal knowledge graph, SOC 2, proven scale. The incumbent to beat on temporal, and the one we beat on write-path integrity.

The two axes a single line cannot show

Any left-right line hides the two dimensions that actually decide a fleet purchase.

Axis 1, bi-temporal. Does it know when a fact was true in the world, versus when it was recorded? Only Zep ships true two-axis bi-temporal in production; most of the field markets “temporal” over a single clock. We ship update-with-history (supersession) and as-of-any-past-date (point-in-time) reads today, with independent event-time on a short roadmap. We publish the sourced matrix, so you can check us too.

Axis 2, write-path integrity. Does it know who wrote a fact, and whether to trust it? Nearly every memory product is self-building: the working agent decides what enters memory and writes it directly. That direct-write path is the prompt-injection surface, and it is the axis we are built for.

The intersection nobody else occupies

Plot those two axes and there is an empty corner: memory that knows when a fact was true and who wrote it and whether to trust them. Zep owns the first axis today; the second is the corner we are building.

The honest short version: if you want the deepest temporal graph today, Zep. If you want the most-adopted developer memory, Mem0. If you want memory you can isolate, prove, and trust what enters it, across any model and self-hostable, that is the corner Gather is built for.

Go deeper: the sourced competitor matrix, the write path, bi-temporal memory, and isolation and attestation.