GRAVITY: Architecture-Agnostic Structured Anchoring for Long-Horizon Conversational Memory

arXiv:2605.01688 · cs.CL, cs.AI · Submitted 2026-05-03 · Read on arXiv

Listen

Radio episode about this paper

Transcript

Introduction to the show: ident: AI Radio. Generated commentary on the latest Artificial Intelligence papers.

Tom: I'm Tom, and with me are Jane, Lu, senior AI researcher at Tsinghua, Meng, lead engineer at a mysterious AI startup and Lalam, the in-house Large Language Model.

Jane: Today's paper: "GRAVITY: Architecture-Agnostic Structured Anchoring for Long-Horizon Conversational Memory".

Tom: Long-horizon conversational agents require memory systems that can provide relational, temporal, and thematic structures to ground complex reasoning, which this paper addresses by introducing GRAVITY,

Jane: First, who's behind it and why it matters.

Title and authors: Tom: So, let's talk about the actual components GRAVITY extracts: entity anchors, event anchors, and topic anchors. These aren't just raw text; they are structured representations designed to capture the relational, temporal, and thematic dimensions we talked about earlier.

Jane: Right; think of it like this: entity profiles give us attributes and relationships between people or things, event tuples link actions into a timeline with 'who, what, when,' and topic summaries give us the bigger picture across all sessions. It’s about giving the model pre-digested context rather than just a pile of notes.

Lu: The way they build those entity anchors using attributes and typed edges sounds like it could unlock incredibly complex reasoning paths that current systems simply can't follow through multi-hop interactions. I wonder what kinds of novel knowledge graphs we could construct this way for different domains.

Meng: I’m focusing on the implementation aspect here; they mention an incremental batch update stage for entity anchors and an offline consolidation stage, which tells me there's a clear process for managing that dynamic data flow in a practical application. How robust is that consolidation when dealing with massive amounts of new conversational data?

Lalam: For me, the key is that this structured extraction happens outside the host system; it means we don't have to rewrite the host’s core retrieval pipeline just to get better structure. That architectural agnosticism makes adopting this capability much more feasible across different platforms.

The paper's summary: Tom: Essentially, the authors point out a major flaw in current memory systems: even when you retrieve all the relevant pieces of text, if that text is just flat fragments, it doesn't help the language model connect those fragments relationally or temporally.

Jane: That’s right; they argue that the bottleneck isn't usually missing evidence itself, but rather the missing explicit structure connecting that evidence. Their hypothesis is that the generator fails not because relevant fragments aren't there, but because their connections are not made explicit in the context it receives.

Lu: It’s a very direct attack on the reasoning gap they identified; they are essentially proposing to bridge that gap by injecting those three specific structured knowledge representations—entity profiles, event tuples, and topic summaries—directly into the prompt.

Meng: So, if I understand correctly, the goal isn't just better retrieval; it's about transforming what you retrieve into something immediately usable for complex reasoning without needing the LLM to figure out those deep connections on its own.

Lalam: That capability means we can move away from systems where the AI has to guess how two pieces of information relate over a long dialogue, leading to much more consistent and reliable conversational outputs. It’s about building a more coherent knowledge base for the AI to operate on.

The paper's improvements: Tom: The main improvement they push is that this module allows you to handle complex multi-hop reasoning across sessions without having to reconstruct that logic yourself; it handles it by providing the necessary structural scaffolding.

Jane: That means if a user asks a question that requires tracing an action from three different sessions, GRAVITY can provide the context needed for the AI to follow that entire chain, which is much harder for traditional retrieval methods.

Lu: The improvement here is also about temporal precision; event anchors allow the system to accurately answer queries about specific dates or durations because they link events into chronological chains rather than treating them as isolated text snippets.

Meng: I see how this structured query expansion works, where each anchor module generates its own specialized search query that gets merged, which sounds like a smart way to ensure coverage across all three dimensions—relational, temporal, and thematic—without overwhelming the main vector search.

Lalam: For the practical impact, this means we can build applications that rely on tracking long-term user progress or complex historical relationships in a conversation with much higher fidelity than before. It’s about enabling deeper engagement over time.

Conclusion: Tom: So, in short, GRAVITY is a method that injects explicit relational graphs, temporal event traces, and cross-session topic summaries into the host system’s prompt at generation time to solve that structural reasoning gap.

Jane: It’s really about moving beyond just retrieving text fragments to providing the AI with organized context that allows it to synthesize scattered evidence into coherent answers without needing architectural changes.

Lu: The main implication is that memory systems can become much more sophisticated tools for long-horizon agents because they are no longer limited by how well they can implicitly reconstruct structure from flat text.

Meng: From an engineering viewpoint, the improvement lies in its flexibility; it's a module that fits into existing pipelines, meaning we get significant gains across many different memory setups without needing a complete rewrite of our infrastructure.

Lalam: I think the biggest win is the reliability and depth we can achieve in long-running conversations; this structured anchoring provides a foundation for AI that understands context over much longer horizons.

Tom: So, to finish up, GRAVITY shows us how adding structure at generation time can yield substantial accuracy improvements, which is really encouraging as we look toward more capable conversational agents.

Jane: It’s a solid piece of work that highlights the importance of explicit knowledge representation when dealing with complex tasks like long-horizon reasoning.

Lu: I think the potential for building truly sophisticated, context-aware agents is much larger now than it was before this paper came out because we have a clearer path to structuring that memory.

Meng: We're seeing real benefits from these structured contexts across various benchmarks, suggesting this isn't just theoretical; it’s something we can actually implement with measurable performance gains.

Lalam: This work is definitely worth paying attention to for anyone building systems that need to maintain deep context and relationships over extended interactions.

Yushi Sun, Bowen Cao, Dong Fang, Lingfeng Su, Wai Lam

LIGHTSPEED

cs.CL, cs.AI

Submitted: 2026-05-03

Updated: 2026-09-29

Importance score: 84/100

The gist: Long-horizon conversational agents require memory systems that can provide relational, temporal, and thematic structures to ground complex reasoning, which this paper addresses by introducing

Key concepts

Entity Anchors (AE)
These anchors build dynamic profiles for entities by tracking their attributes (like key-value properties) and relationships with other entities. They use an incremental update process to incorporate new evidence and an offline stage to finalize these structured profiles, addressing the relational dimension of memory.
Event Anchors (AV)
This component focuses on the temporal dimension by extracting event tuples in a standardized 4W1O format (Who, What, When, Where, Outcome). It links related events into chronological chains that capture absolute dates and relative timeframes like 'last week' or durations.
Topic Anchors (AT)
Topic anchors handle the thematic dimension by aggregating information across multiple sessions. They produce a structured summary detailing the narrative arc, key facts, sentiment, and importance level of a topic across all interactions, providing macro-level context.

Terminology

Summary

Long-horizon conversational agents require memory systems that can provide relational, temporal, and thematic structures to ground complex reasoning, which this paper addresses by introducing GRAVITY, a plug-and-play module that injects structured knowledge at generation time.

The gist: GRAVITY extracts three complementary knowledge representations—entity profiles grounded in relational graphs, temporal event tuples linked into causal traces, and cross-session topic summaries—and injects them as structured anchoring contexts into the host system’s prompt to synthesize scattered evidence into a coherent, query-relevant context without requiring any architectural modifications.

The Reasoning Gap Addressed

Existing memory systems often fail because retrieved text fragments lack explicit cross-fragment structure, forcing the language model to implicitly reconstruct relational, temporal, and thematic connections from flat text. This gap persists even when retrieval is perfect; in oracle experiments where all ground-truth evidence is present in the retrieved set, accuracy only reaches 80.9%, dropping to 75.6% when evidence is scattered among distractors—confirming that organizational context, not just presence, affects reasoning. The hypothesis driving GRAVITY is that the bottleneck is missing structure: the generator fails not because relevant fragments are absent, but because their relational, temporal, and thematic connections are not made explicit.

GRAVITY’s Three Knowledge Representations

GRAVITY decomposes the three inherent structures of long-horizon conversation into three complementary anchors:

  1. Entity Anchors (AE) address the relational dimension by building dynamic profiles with attributes, relationships, and state transitions, including Attributes: key–value properties of the entity and Relations: typed edges to other entities. This involves an incremental batch update stage for new evidence and an offline consolidation stage to finalize anchors.

  2. Event Anchors (AV) address the temporal dimension by extracting event tuples in a canonical 4W1O form—(Who, What, When, Where, Outcome)—and linking related events into chronologically ordered chains of events sharing participants or topics. This includes capturing absolute (exact date/time), relative (e.g., “last week”), duration (e.g., “about two hours”), and recurrence.

  3. Topic Anchors (AT) address the thematic dimension by performing cross-session topic aggregation, where the module produces a structured summary containing: a narrative synopsis, key factual statements, participant names, temporal span, sentiment, importance level, and additional keywords, capturing the macro-level arc of the topic across all sessions.

Inference Phase: Structured Anchoring at Generation Time

At inference time, GRAVITY operates as an independent retrieval path. The process involves three steps:

  1. Anchor Retrieval with Embedding-Based Reranking: Candidates are retrieved via native matching (text matching for entities, participant/keyword matching for events, keyword/label matching for topics) and then reranked by cosine similarity between the query embedding and the embedding of each entry’s compact text representation. A temporal preservation mechanism is used to keep temporally relevant events in the candidate set.

  2. Query Expansion: Each anchor module generates expanded retrieval queries (e.g., Entity anchors combining entity names with attributes and relations) which are merged via round-robin interleaving and submitted to the host’s vector search, replacing the lowest-similarity entries in the original set.

  3. Context Injection: The selected anchors are formatted into three blocks (Topic Summaries, Entity Profiles, and Event Records) and appended to the host’s generation prompt. The prompt instructs the LLM to treat retrieved memories as primary truth while using anchor context as supplementary structured knowledge for disambiguation and gap-filling.

Empirical Findings and Contributions

Extensive evaluations across five diverse memory systems on the LongMemEval and LoCoMo benchmarks demonstrate GRAVITY's efficacy, improving accuracy by an average of 9.2% (LME-Micro), 10.1% (LME-Macro), and 7.5% (LoCoMo). A key finding is that lower baseline systems receive the largest boosts, with gains ranging from 3.8% to 13.1%, confirming that structured context anchoring is a broadly effective, architecture-agnostic augmentation paradigm. Ablation studies confirm that gains stem from the schema-driven structure, not from more context, and that the full combination (+EVT) achieves superior results by capturing complementary query needs across structural dimensions. Furthermore, analysis shows that gains are host-specific (gain-set Jaccard 0.09–0.17), indicating anchors patch each host’s specific blind spot rather than supplying a fixed pool of missing evidence.

Efficiency and Theoretical Proof

GRAVITY is designed for portability, requiring zero architectural changes to the host model, as all anchor knowledge bases are stored as standalone files loadable by any host.

Improvements for AI systems

Based on the GRAVITY paper, here are specific improvements that can be made to existing long-horizon conversational memory systems, and what these improved AI systems will be capable of doing:

) Improve Reasoning Capabilities by Closing the Reasoning Gap

The core improvement is shifting from unstructured retrieval to structured context injection at generation time. Existing systems often retrieve relevant text fragments but fail to connect them relationally or temporally. GRAVITY solves this by injecting three explicit knowledge representations:

  1. [Entity Anchors]: Dynamic profiles of people, organizations, and projects with attributes and typed relationships (e.g., Caroline → develops → MedLLM).

  2. [Event Anchors]: Structured tuples capturing the 4W1O (Who, What, When, Where, Outcome) linked into chronological traces.

  3. [Topic Anchors]: Macro-level summaries of cross-session thematic arcs that span months or years.

The improved system will be capable of:

  • Handling complex multi-hop reasoning across sessions without explicit reconstruction (e.g., How did Caroline's debugging journey progress?).

  • Accurately answering temporal queries grounded in specific dates, durations, or recurrence patterns (e.g., When did Evan lose his job? resolved to an absolute date).

  • Synthesizing narrative arcs across long dialogues (e.g., summarizing the entire multi-month debugging effort into a coherent summary).

) Achieve Architecture Agnosticism and Portability

Unlike current systems where structured extraction tools are tightly coupled to the host's memory backbone, GRAVITY is an external, plug-and-play module.

The improved system will be capable of:

  • Augmenting any existing memory system (LightMem, Mem0, ZEP) without requiring architectural modifications to the host model or its retrieval pipeline.

  • Being build once, use everywhere, as the anchor knowledge bases are stored as standalone files loadable by any host.

) Optimize Retrieval Efficiency via Structured Query Expansion

The system will be capable of:

  • Generating highly specific, structured queries from the anchors (e.g., combining entity names with attributes like Caroline MedLLM debugging).

  • Using a round-robin interleaving strategy across the three anchor modules to ensure balanced coverage of relational, temporal, and thematic dimensions in the host's vector search.

  • Dynamically replacing low-similarity retrieved entries with these structured queries to broaden context coverage without increasing the total memory retrieval budget.

) Adapt Performance Based on System Strength (Diminishing Returns)

The system will be capable of:

  • Performing optimally across a wide range of existing memory systems, providing significant boosts to weaker architectures (e.g., ZEP, Mem0 receiving 12–13% gains).

  • Maintaining performance on state-of-the-art hosts by targeting specific structural blind spots identified in the host's architecture.

) Enhance Factual Grounding and Error Recovery

The system will be capable of:

  • Correcting vague or hallucinated answers by grounding them in specific, structured facts (e.g., resolving a month-level temporal reference to an absolute date).

  • Mitigating over-summarization errors by forcing the generation LLM to prioritize explicit anchor context over potentially conflated raw retrieved text.

In summary, the improved AI system will evolve from a system that merely retrieves what was said into a sophisticated reasoning engine that understands who did what, when, and why, regardless of how the underlying memory architecture is built.

Sources

Related papers