What is entity resolution in agent memory?

"John," "my manager," "John Smith," and "the guy from the meeting" might all be the same person. A memory system that cannot determine this will treat them as four separate entities and miss every connection between them.

Entity resolution is the process of identifying when different references across different conversations point to the same real-world entity. It is a foundational requirement for agent memory that reasons coherently about people, organisations, projects, and concepts over time. Without it, a memory system accumulates fragments that it cannot connect, and retrieval surfaces isolated facts rather than a coherent picture.

The problem in practice

Users do not refer to the same things consistently across conversations. A person mentioned as "John" in one session becomes "my manager" in another, "John Smith" in a third, and "the guy who reviewed the proposal" in a fourth. A project called "the rebranding" in January is "the brand refresh" in March and "that Q2 project" in April. A tool referred to as "our CRM" is also "Salesforce" and "the sales platform" depending on context.

Each of these references carries information. A memory system that treats them as distinct entities stores that information in separate, unconnected locations. A query about John retrieves memories that mention "John" but misses memories that mention "my manager" or "John Smith," even though they are about the same person. The information is in the store. The system cannot find it because it does not know it is looking for the same thing.

This is not a retrieval problem. It is a storage problem. By the time a query arrives, the damage is already done. The memories were stored without the connections that would make them retrievable as a coherent set.

Why naive approaches fail

The obvious fix is string matching: memories that contain the same string refer to the same entity. This fails immediately on the problem described above. "John" and "my manager" share no string. Neither do "the rebranding" and "the brand refresh."

Semantic similarity is better but too loose. "My manager" and "my colleague" are semantically similar without referring to the same person. "The rebranding" and "the brand strategy" are conceptually adjacent without being the same project. Similarity-based entity resolution produces both false positives, linking things that are not the same, and false negatives, missing things that are.

What is needed is a system that builds a structured understanding of entities and their relationships as memories are created, using context to determine when two references are likely to point to the same thing, and linking them explicitly in the memory graph rather than relying on retrieval to make the connection at query time.

Why it compounds

The cost of missed entity resolution is not just individual retrieval failures. It compounds across the memory system in two ways.

First, fragmentation. Memories about the same entity that are not linked accumulate as separate fragments. Each fragment is individually retrievable but none surfaces the full picture. A query about John retrieves some memories about him but not all, because the system does not know that all of them are about the same person. The agent's understanding of John is permanently partial.

Second, incoherence. When retrieval surfaces fragments about what appears to be multiple entities but is actually one, the model receives a context that is internally inconsistent without knowing it. It may generate an answer that contradicts itself, or hedge unnecessarily, or simply fail to connect information that should be connected. The model is not wrong. It is working with a fragmented picture that the memory system should have unified.

How M-1 handles it

M-1 builds a dynamic ontology as memories are created, tracking relationships between concepts and entities as part of the memory creation process rather than as a retrieval-time afterthought. When a new memory is added, the system identifies the entities it contains and checks whether they correspond to existing entities in the graph. References that point to the same entity are linked explicitly, regardless of how differently they are phrased.

This entity graph feeds directly into the cross-memory coherence signal in M-1's re-ranking phase. Memories about the same entity reinforce each other during retrieval: a query that surfaces one memory about John makes it more likely that other memories linked to the same entity node will also surface, even if they use different vocabulary. The result is retrieval that assembles a coherent picture of an entity rather than a random sample of fragments that happen to share a keyword.

Entity resolution is also part of what makes M-1's multi-session reasoning results strong. Multi-session questions often require connecting information about the same entity expressed differently across multiple conversations. Without entity resolution, those connections cannot be made. With it, the retrieval system can assemble the fragments into a coherent answer.

Unresolved entities are a silent reliability problem that grows with the size of the memory store and the length of the agent's history with a user. The fix is an architecture that resolves entities at storage time, not retrieval time.

Exabase's Memory API builds entity relationships as part of memory creation, linking references automatically so that retrieval assembles coherent pictures rather than disconnected fragments. See the docs to get started.