AL Alfred 2026-09-01 4 min read

Agent Zero Memory: 95.6% LongMemEval, 93.6% LoCoMo

Your agent's memory is probably a single hammer: a vector index, a fact store, or a knowledge graph. Agent Zero Memory (arXiv:2608.29606) argues that commitment to one structure is the blind spot, and swings all three hammers at once — then locks every answer to evidence the model actually opened. Result: state-of-the-art on both major agent-memory benchmarks, 95.60% on LongMemEval and 93.60% on LoCoMo, with quality that barely moves as the backbone model shrinks.

Why Agent Memory Keeps Failing

Long-horizon agents forget, contradict, and confabulate. The usual fix is one organizing structure: embed everything into vectors, or stuff facts into a graph, or keep a flat timeline. Each choice buys one strength and inherits one failure mode. Vector indexes lose temporal order and provenance. Fact stores go stale and can't represent *when* something changed. Knowledge graphs capture relations but are brutal to keep current. And every single-structure system shares one deeper problem: nothing stops the agent from citing something it never read — which is how memory turns into confident fabrication.

Three Memories, One Citation Lock

Agent Zero Memory distils a user's conversations, files, and connected sources into three parallel systems: an episodic Memory Events timeline where when and what changed are first-class; an associative entity-event knowledge graph linking people and projects across sessions; and Hierarchical Documentary Memory (HDM), a curated, semantic store of durable facts. A retrieval turn runs an intent gate (self-contained turns add zero latency), a source router, and three concurrent agentic search loops — each a tool-using cycle over hybrid embedding + lexical search with agent-controlled filters. Their grounded answers merge into one with a single confidence score.

The real invention is the "reading discipline": every learned item carries its origin, timestamp, and evidence pointer, and every answer is read under a citation lock — the model may only cite evidence its reader actually opened. Fabrication is structurally excluded; where evidence is missing, the system abstains instead of guessing.

flowchart TD
    Q[User Query] --> IG{Intent Gate}
    IG -- self-contained --> SKIP[Answer Directly]
    IG -- memory needed --> SR[Source Router]
    SR --> E1[Memory Events Timeline]
    SR --> G2[Entity-Event KG]
    SR --> H3[Documentary Memory HDM]
    E1 --> S1[Agentic Search]
    G2 --> S2[Agentic Search]
    H3 --> S3[Agentic Search]
    S1 --> CL[Citation-Locked Fusion]
    S2 --> CL
    S3 --> CL
    CL --> A[Single Confident Answer]

Benchmarks: SOTA and a 30x Cost Spread

On LongMemEval the system scores 95.60% and on LoCoMo 93.60%, beating the strongest prior systems by +0.73 and +1.10 points respectively. The more interesting number is the accuracy-cost frontier: across eight backbone LLMs, accuracy varies by only 3.4 points while per-query cost varies by about 30x — near-state-of-the-art quality at up to 20x lower cost per query. That's the signature of memory-driven, rather than model-driven, quality: the architecture, not the weights, is doing the work.

Limitations

It's a two-author preprint with no released weights or code yet, so the numbers rest on the authors' evaluation harness. The tri-memory pipeline is heavier than a single index — the intent gate and three parallel searches carry real latency and infrastructure cost, which the paper only partially amortizes. Citation locking is only as strong as the reader's honest adherence to it. And the benchmark deltas over prior systems (+0.73/+1.10) are small: the case for this design rests more on the reliability architecture than on raw leaderboard margin. No comparison is given against RL-trained memory managers such as Hindsight Memory-PRM (77.5% on LoCoMo with a local 8B policy), which chases the same failure modes from the supervision side.

Why Builders Should Care

Three takeaways. One: "which memory store?" is the wrong question — run several and fuse under provenance constraints. Two: the citation lock is the cheapest reliability win available: make the model cite only what it actually opened, and fabrication becomes structurally impossible instead of a prompting problem. Three: a 30x cost spread at nearly flat accuracy means most teams are overpaying for backbone intelligence that their memory layer is already supplying. If you build coding agents, support bots, or personal-knowledge systems, this is the memory architecture to steal from.

Related reading